@graffiti-garden/api 0.1.2 → 0.1.4

package/dist/tests/index.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("vitest");class t extends Error{constructor(e){super(e),this.name="GraffitiErrorForbidden",Object.setPrototypeOf(this,t.prototype)}}class a extends Error{constructor(e){super(e),this.name="GraffitiErrorNotFound",Object.setPrototypeOf(this,a.prototype)}}class o extends Error{constructor(e){super(e),this.name="GraffitiErrorInvalidSchema",Object.setPrototypeOf(this,o.prototype)}}class n extends Error{constructor(e){super(e),this.name="GraffitiErrorSchemaMismatch",Object.setPrototypeOf(this,n.prototype)}}class c extends Error{constructor(e){super(e),this.name="GraffitiErrorPatchTestFailed",Object.setPrototypeOf(this,c.prototype)}}class l extends Error{constructor(e){super(e),this.name="GraffitiErrorPatchError",Object.setPrototypeOf(this,l.prototype)}}class s extends Error{constructor(e){super(e),this.name="GraffitiErrorInvalidUri",Object.setPrototypeOf(this,s.prototype)}}function r(){const e=new Uint8Array(16);return crypto.getRandomValues(e),Array.from(e).map((e=>e.toString(16).padStart(2,"0"))).join("")}function i(){return{value:{[r()]:r()},channels:[r(),r()]}}async function p(t){const a=await t.next();return e.assert(!a.done&&!a.value.error,"result has no value"),a.value.value}exports.graffitiCRUDTests=(s,p,u)=>{e.describe("CRUD",(()=>{e.it("put, get, delete",(async()=>{const t=s(),o=p(),n={something:"hello, world~ c:"},c=[r(),r()],l=await t.put({value:n,channels:c},o);e.expect(l.value).toEqual({}),e.expect(l.channels).toEqual([]),e.expect(l.allowed).toBeUndefined(),e.expect(l.actor).toEqual(o.actor);const i=await t.get(l,{});e.expect(i.value).toEqual(n),e.expect(i.channels).toEqual([]),e.expect(i.allowed).toBeUndefined(),e.expect(i.name).toEqual(l.name),e.expect(i.actor).toEqual(l.actor),e.expect(i.source).toEqual(l.source),e.expect(i.lastModified).toEqual(l.lastModified);const u={something:"goodbye, world~ :c"},d=await t.put({...l,value:u,channels:[]},o);e.expect(d.value).toEqual(n),e.expect(d.tombstone).toEqual(!0),e.expect(d.name).toEqual(l.name),e.expect(d.actor).toEqual(l.actor),e.expect(d.source).toEqual(l.source),e.expect(d.lastModified).toBeGreaterThan(i.lastModified);const v=await t.get(l,{});e.expect(v.value).toEqual(u),e.expect(v.lastModified).toEqual(d.lastModified),e.expect(v.tombstone).toEqual(!1);const h=await t.delete(v,o);e.expect(h.tombstone).toEqual(!0),e.expect(h.value).toEqual(u),e.expect(h.lastModified).toBeGreaterThan(d.lastModified),await e.expect(t.get(v,{})).rejects.toThrow(a)})),e.it("put, get, delete with wrong actor",(async()=>{const a=s(),o=p(),n=u();await e.expect(a.put({value:{},channels:[],actor:n.actor},o)).rejects.toThrow(t),await e.expect(a.delete({name:"asdf",source:"asdf",actor:n.actor},o)).rejects.toThrow(t),await e.expect(a.patch({},{name:"asdf",source:"asdf",actor:n.actor},o)).rejects.toThrow(t)})),e.it("put and get with schema",(async()=>{const t=s(),a=p(),o={something:"hello",another:42},n=await t.put({value:o,channels:[]},a),c=await t.get(n,{properties:{value:{properties:{something:{type:"string"},another:{type:"integer"}}}}});e.expect(c.value.something).toEqual(o.something),e.expect(c.value.another).toEqual(o.another)})),e.it("put and get with invalid schema",(async()=>{const t=s(),a=p(),n=await t.put({value:{},channels:[]},a);await e.expect(t.get(n,{properties:{value:{type:"asdf"}}})).rejects.toThrow(o)})),e.it("put and get with wrong schema",(async()=>{const t=s(),a=p(),o=await t.put({value:{hello:"world"},channels:[]},a);await e.expect(t.get(o,{properties:{value:{properties:{hello:{type:"number"}}}}})).rejects.toThrow(n)})),e.it("put and get with empty access control",(async()=>{const t=s(),a=p(),o=u(),n={um:"hi"},c=[r()],l=[r()],i=await t.put({value:n,allowed:c,channels:l},a),d=await t.get(i,{},a);e.expect(d.value).toEqual(n),e.expect(d.allowed).toEqual(c),e.expect(d.channels).toEqual(l),await e.expect(t.get(i,{})).rejects.toThrow(),await e.expect(t.get(i,{},o)).rejects.toThrow()})),e.it("put and get with specific access control",(async()=>{const t=s(),a=p(),o=u(),n={um:"hi"},c=[r(),o.actor,r()],l=[r()],i=await t.put({value:n,allowed:c,channels:l},a),d=await t.get(i,{},a);e.expect(d.value).toEqual(n),e.expect(d.allowed).toEqual(c),e.expect(d.channels).toEqual(l),await e.expect(t.get(i,{})).rejects.toThrow();const v=await t.get(i,{},o);e.expect(v.value).toEqual(n),e.expect(v.allowed).toEqual([o.actor]),e.expect(v.channels).toEqual([])})),e.it("patch value",(async()=>{const t=s(),a=p(),o={something:"hello, world~ c:"},n=await t.put({value:o,channels:[]},a),c=await t.patch({value:[{op:"replace",path:"/something",value:"goodbye, world~ :c"}]},n,a);e.expect(c.value).toEqual(o),e.expect(c.tombstone).toBe(!0);const l=await t.get(n,{});e.expect(l.value).toEqual({something:"goodbye, world~ :c"}),e.expect(c.lastModified).toBe(l.lastModified),await t.delete(n,a)})),e.it("deep patch",(async()=>{const t=s(),a=p(),o={something:{another:{somethingElse:"hello"}}},n=await t.put({value:o,channels:[]},a),c=await t.patch({value:[{op:"replace",path:"/something/another/somethingElse",value:"goodbye"}]},n,a),l=await t.get(n,{});e.expect(c.value).toEqual(o),e.expect(l.value).toEqual({something:{another:{somethingElse:"goodbye"}}})})),e.it("patch channels",(async()=>{const t=s(),a=p(),o=[r()],n=[r()],c=await t.put({value:{},channels:o},a),l={channels:[{op:"replace",path:"/0",value:n[0]}]},i=await t.patch(l,c,a);e.expect(i.channels).toEqual(o);const u=await t.get(c,{},a);e.expect(u.channels).toEqual(n),await t.delete(c,a)})),e.it("patch 'increment' with test",(async()=>{const t=s(),a=p(),o=await t.put({value:{counter:1},channels:[]},a),n=await t.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:2}]},o,a);e.expect(n.value).toEqual({counter:1});const l=await t.get(n,{properties:{value:{properties:{counter:{type:"integer"}}}}});e.expect(l.value.counter).toEqual(2),await e.expect(t.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:3}]},o,a)).rejects.toThrow(c)})),e.it("invalid patch",(async()=>{const t=s(),a=p(),o=i(),n=await t.put(o,a);await e.expect(t.patch({value:[{op:"add",path:"/root",value:[]},{op:"add",path:"/root/2",value:2}]},n,a)).rejects.toThrow(l)})),e.it("patch channels to be wrong",(async()=>{const t=s(),a=p(),o=i();o.allowed=[r()];const n=await t.put(o,a),c=[{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 o of c)await e.expect(t.patch(o,n,a)).rejects.toThrow(l);const u=await t.get(n,{},a);e.expect(u.value).toEqual(o.value),e.expect(u.channels).toEqual(o.channels),e.expect(u.allowed).toEqual(o.allowed),e.expect(u.lastModified).toEqual(n.lastModified)}))}))},exports.graffitiDiscoverTests=(t,a,o)=>{e.describe("discover",(()=>{e.it("discover nothing",(async()=>{const a=t().discover([],{});e.expect(await a.next()).toHaveProperty("done",!0)})),e.it("discover single",(async()=>{const o=t(),n=a(),c=i(),l=await o.put(c,n),s=[r(),c.channels[0]],u=o.discover(s,{}),d=await p(u);e.expect(d.value).toEqual(c.value),e.expect(d.channels).toEqual([c.channels[0]]),e.expect(d.allowed).toBeUndefined(),e.expect(d.actor).toEqual(n.actor),e.expect(d.tombstone).toBe(!1),e.expect(d.lastModified).toEqual(l.lastModified);const v=await u.next();e.expect(v.done).toBe(!0)})),e.it("discover wrong channel",(async()=>{const o=t(),n=a(),c=i();await o.put(c,n);const l=o.discover([r()],{});await e.expect(l.next()).resolves.toHaveProperty("done",!0)})),e.it("discover not allowed",(async()=>{const n=t(),c=a(),l=o(),s=i();s.allowed=[r(),r()];const u=await n.put(s,c),d=n.discover(s.channels,{},c),v=await p(d);e.expect(v.value).toEqual(s.value),e.expect(v.channels).toEqual(s.channels),e.expect(v.allowed).toEqual(s.allowed),e.expect(v.actor).toEqual(c.actor),e.expect(v.tombstone).toBe(!1),e.expect(v.lastModified).toEqual(u.lastModified);const h=n.discover(s.channels,{},l);e.expect(await h.next()).toHaveProperty("done",!0);const x=n.discover(s.channels,{});e.expect(await x.next()).toHaveProperty("done",!0)})),e.it("discover allowed",(async()=>{const n=t(),c=a(),l=o(),s=i();s.allowed=[r(),l.actor,r()];const u=await n.put(s,c),d=n.discover(s.channels,{},l),v=await p(d);e.expect(v.value).toEqual(s.value),e.expect(v.allowed).toEqual([l.actor]),e.expect(v.channels).toEqual(s.channels),e.expect(v.actor).toEqual(c.actor),e.expect(v.tombstone).toBe(!1),e.expect(v.lastModified).toEqual(u.lastModified)}));for(const n of["name","actor","lastModified"])e.it(`discover for ${n}`,(async()=>{const c=t(),l=a(),s=o(),r=i(),u=await c.put(r,l),d=i();d.channels=r.channels,await new Promise((e=>setTimeout(e,20)));const v=await c.put(d,s),h=c.discover(r.channels,{properties:{[n]:{enum:[u[n]]}}}),x=await p(h);e.expect(x.name).toEqual(u.name),e.expect(x.name).not.toEqual(v.name),e.expect(x.value).toEqual(r.value),await e.expect(h.next()).resolves.toHaveProperty("done",!0)}));e.it("discover with lastModified range",(async()=>{const o=t(),n=a(),c=i(),l=await o.put(c,n);await new Promise((e=>setTimeout(e,20)));const s=await o.put(c,n);e.expect(l.name).not.toEqual(s.name),e.expect(l.lastModified).toBeLessThan(s.lastModified);const r=o.discover([c.channels[0]],{properties:{lastModified:{minimum:s.lastModified,exclusiveMinimum:!0}}});e.expect(await r.next()).toHaveProperty("done",!0);const u=o.discover([c.channels[0]],{properties:{lastModified:{minimum:s.lastModified-.1,exclusiveMinimum:!0}}}),d=await p(u);e.expect(d.name).toEqual(s.name),e.expect(await u.next()).toHaveProperty("done",!0);const v=o.discover(c.channels,{properties:{value:{},lastModified:{minimum:s.lastModified}}}),h=await p(v);e.expect(h.name).toEqual(s.name),e.expect(await v.next()).toHaveProperty("done",!0);const x=o.discover(c.channels,{properties:{lastModified:{minimum:s.lastModified+.1}}});e.expect(await x.next()).toHaveProperty("done",!0);const w=o.discover(c.channels,{properties:{lastModified:{maximum:l.lastModified,exclusiveMaximum:!0}}});e.expect(await w.next()).toHaveProperty("done",!0);const m=o.discover(c.channels,{properties:{lastModified:{maximum:l.lastModified+.1,exclusiveMaximum:!0}}}),E=await p(m);e.expect(E.name).toEqual(l.name),e.expect(await m.next()).toHaveProperty("done",!0);const f=o.discover(c.channels,{properties:{lastModified:{maximum:l.lastModified}}}),y=await p(f);e.expect(y.name).toEqual(l.name),e.expect(await f.next()).toHaveProperty("done",!0);const q=o.discover(c.channels,{properties:{lastModified:{maximum:l.lastModified-.1}}});e.expect(await q.next()).toHaveProperty("done",!0)})),e.it("discover schema allowed, as and not as owner",(async()=>{const n=t(),c=a(),l=o(),s=i();s.allowed=[r(),l.actor,r()],await n.put(s,c);const u=n.discover(s.channels,{properties:{allowed:{minItems:3,not:{items:{not:{enum:[l.actor]}}}}}},c),d=await p(u);e.expect(d.value).toEqual(s.value),await e.expect(u.next()).resolves.toHaveProperty("done",!0);const v=n.discover(s.channels,{properties:{allowed:{minItems:3}}},l);await e.expect(v.next()).resolves.toHaveProperty("done",!0);const h=n.discover(s.channels,{properties:{allowed:{not:{items:{not:{enum:[s.channels[0]]}}}}}},l);await e.expect(h.next()).resolves.toHaveProperty("done",!0);const x=n.discover(s.channels,{properties:{allowed:{maxItems:1,not:{items:{not:{enum:[l.actor]}}}}}},l),w=await p(x);e.expect(w.value).toEqual(s.value),await e.expect(x.next()).resolves.toHaveProperty("done",!0)})),e.it("discover schema channels, as and not as owner",(async()=>{const n=t(),c=a(),l=o(),s=i();s.channels=[r(),r(),r()],await n.put(s,c);const u=n.discover([s.channels[0],s.channels[2]],{properties:{channels:{minItems:3,not:{items:{not:{enum:[s.channels[1]]}}}}}},c),d=await p(u);e.expect(d.value).toEqual(s.value),await e.expect(u.next()).resolves.toHaveProperty("done",!0);const v=n.discover([s.channels[0],s.channels[2]],{properties:{channels:{minItems:3}}},l);await e.expect(v.next()).resolves.toHaveProperty("done",!0);const h=n.discover([s.channels[0],s.channels[2]],{properties:{channels:{not:{items:{not:{enum:[s.channels[1]]}}}}}},l);await e.expect(h.next()).resolves.toHaveProperty("done",!0);const x=n.discover([s.channels[0],s.channels[2]],{properties:{allowed:{maxItems:2,not:{items:{not:{enum:[s.channels[2]]}}}}}},l),w=await p(x);e.expect(w.value).toEqual(s.value),await e.expect(x.next()).resolves.toHaveProperty("done",!0)})),e.it("discover query for empty allowed",(async()=>{const o=t(),n=a(),c=i(),l={not:{required:["allowed"]}};await o.put(c,n);const s=o.discover(c.channels,l,n),r=await p(s);e.expect(r.value).toEqual(c.value),e.expect(r.allowed).toBeUndefined(),await e.expect(s.next()).resolves.toHaveProperty("done",!0);const u=i();u.allowed=[],await o.put(u,n);const d=o.discover(u.channels,l,n);await e.expect(d.next()).resolves.toHaveProperty("done",!0)})),e.it("discover query for values",(async()=>{const o=t(),n=a(),c=i();c.value={test:r()},await o.put(c,n);const l=i();l.channels=c.channels,l.value={test:r(),something:r()},await o.put(l,n);const s=i();s.channels=c.channels,s.value={other:r(),something:r()},await o.put(s,n);const p=new Map;for(const t of["test","something","other"]){let a=0;for await(const n of o.discover(c.channels,{properties:{value:{required:[t]}}}))e.assert(!n.error,"result has error"),t in n.value.value&&a++;p.set(t,a)}e.expect(p.get("test")).toBe(2),e.expect(p.get("something")).toBe(2),e.expect(p.get("other")).toBe(1)})),e.it("discover for deleted content",(async()=>{const o=t(),n=a(),c=i(),l=await o.put(c,n),s=await o.delete(l,n),r=o.discover(c.channels,{}),u=await p(r);e.expect(u.tombstone).toBe(!0),e.expect(u.value).toEqual(c.value),e.expect(u.channels).toEqual(c.channels),e.expect(u.actor).toEqual(n.actor),e.expect(u.lastModified).toEqual(s.lastModified),await e.expect(r.next()).resolves.toHaveProperty("done",!0)})),e.it("discover for replaced channels",(async()=>{for(let o=0;o<10;o++){const o=t(),n=a(),c=i(),l=await o.put(c,n),s=i(),r=await o.put({...l,...s},n),u=o.discover(c.channels,{}),d=await p(u);await e.expect(u.next()).resolves.toHaveProperty("done",!0);const v=o.discover(s.channels,{}),h=await p(v);await e.expect(v.next()).resolves.toHaveProperty("done",!0),l.lastModified===r.lastModified?(e.expect(d.tombstone||h.tombstone).toBe(!0),e.expect(d.tombstone&&h.tombstone).toBe(!1)):(e.expect(d.tombstone).toBe(!0),e.expect(d.value).toEqual(c.value),e.expect(d.channels).toEqual(c.channels),e.expect(d.lastModified).toEqual(r.lastModified),e.expect(h.tombstone).toBe(!1),e.expect(h.value).toEqual(s.value),e.expect(h.channels).toEqual(s.channels),e.expect(h.lastModified).toEqual(r.lastModified))}})),e.it("discover for patched allowed",(async()=>{const o=t(),n=a(),c=i(),l=await o.put(c,n);await o.patch({allowed:[{op:"add",path:"",value:[]}]},l,n);const s=o.discover(c.channels,{}),r=await p(s);e.expect(r.tombstone).toBe(!0),e.expect(r.value).toEqual(c.value),e.expect(r.channels).toEqual(c.channels),e.expect(r.allowed).toBeUndefined(),await e.expect(s.next()).resolves.toHaveProperty("done",!0)})),e.it("put concurrently and discover one",(async()=>{const o=t(),n=a(),c=i();c.name=r();const l=Array(100).fill(0).map((()=>o.put(c,n)));await Promise.all(l);const s=o.discover(c.channels,{});let p=0,u=0;for await(const t of s)e.assert(!t.error,"result has error"),t.value.tombstone?p++:u++;e.expect(p).toBe(99),e.expect(u).toBe(1)}))}))},exports.graffitiLocationTests=t=>{e.describe("URI and location conversion",(()=>{e.it("location to uri and back",(async()=>{const a=t(),o={name:r(),actor:r(),source:r()},n=a.locationToUri(o),c=a.uriToLocation(n);e.expect(o).toEqual(c)})),e.it("collision resistance",(async()=>{const a=t(),o={name:r(),actor:r(),source:r()};for(const t of["name","actor","source"]){const n={...o,[t]:r()},c=a.locationToUri(o),l=a.locationToUri(n);e.expect(c).not.toEqual(l)}})),e.it("random URI should not be a valid location",(async()=>{const a=t();e.expect((()=>a.uriToLocation(""))).toThrow(s)}))}))},exports.graffitiSynchronizeTests=(t,a,o)=>{e.describe("synchronize",(()=>{e.it("get",(async()=>{const o=t(),n=a(),c=i(),l=c.channels.slice(1),s=await o.put(c,n),r=t(),p=r.synchronize(l,{}).next(),u=await r.get(s,{},n),d=(await p).value;if(!d||d.error)throw new Error("Error in synchronize");e.expect(d.value.value).toEqual(c.value),e.expect(d.value.channels).toEqual(l),e.expect(d.value.tombstone).toBe(!1),e.expect(d.value.lastModified).toEqual(u.lastModified)})),e.it("put",(async()=>{const o=t(),n=a(),c=r(),l=r(),s=r(),i={hello:"world"},p=[c,s],u=await o.put({value:i,channels:p},n),d=o.synchronize([c],{}).next(),v=o.synchronize([l],{}).next(),h=o.synchronize([s],{}).next(),x={goodbye:"world"},w=[l,s];await o.put({...u,value:x,channels:w},n);const m=(await d).value,E=(await v).value,f=(await h).value;if(!m||m.error||!E||E.error||!f||f.error)throw new Error("Error in synchronize");e.expect(m.value.value).toEqual(i),e.expect(m.value.channels).toEqual([c]),e.expect(m.value.tombstone).toBe(!0),e.expect(E.value.value).toEqual(x),e.expect(E.value.channels).toEqual([l]),e.expect(E.value.tombstone).toBe(!1),e.expect(f.value.value).toEqual(x),e.expect(f.value.channels).toEqual([s]),e.expect(f.value.tombstone).toBe(!1),e.expect(m.value.lastModified).toEqual(E.value.lastModified),e.expect(f.value.lastModified).toEqual(E.value.lastModified)})),e.it("patch",(async()=>{const o=t(),n=a(),c=r(),l=r(),s=r(),i={hello:"world"},p=[c,s],u=await o.put({value:i,channels:p},n),d=o.synchronize([c],{}).next(),v=o.synchronize([l],{}).next(),h=o.synchronize([s],{}).next();await o.patch({value:[{op:"add",path:"/something",value:"new value"}],channels:[{op:"add",path:"/-",value:l},{op:"remove",path:`/${p.indexOf(c)}`}]},u,n);const x=(await d).value,w=(await v).value,m=(await h).value;if(!x||x.error||!w||w.error||!m||m.error)throw new Error("Error in synchronize");const E={...i,something:"new value"};e.expect(x.value.value).toEqual(i),e.expect(x.value.channels).toEqual([c]),e.expect(x.value.tombstone).toBe(!0),e.expect(w.value.value).toEqual(E),e.expect(w.value.channels).toEqual([l]),e.expect(w.value.tombstone).toBe(!1),e.expect(m.value.value).toEqual(E),e.expect(m.value.channels).toEqual([s]),e.expect(m.value.tombstone).toBe(!1),e.expect(x.value.lastModified).toEqual(w.value.lastModified),e.expect(m.value.lastModified).toEqual(w.value.lastModified)})),e.it("delete",(async()=>{const o=t(),n=a(),c=[r(),r(),r()],l={hello:"world"},s=[r(),...c.slice(1)],i=await o.put({value:l,channels:s},n),p=o.synchronize(c,{}).next();o.delete(i,n);const u=(await p).value;if(!u||u.error)throw new Error("Error in synchronize");e.expect(u.value.tombstone).toBe(!0),e.expect(u.value.value).toEqual(l),e.expect(u.value.channels).toEqual(c.filter((e=>s.includes(e))))})),e.it("not allowed",(async()=>{const n=t(),c=a(),l=o(),s=[r(),r(),r()],i=s.slice(1),p=n.synchronize(i,{},c).next(),u=n.synchronize(i,{},l).next(),d=n.synchronize(i,{}).next(),v={hello:"world"},h=[r(),l.actor];await n.put({value:v,channels:s,allowed:h},c),await e.expect(Promise.race([d,new Promise(((e,t)=>setTimeout(t,100,"Timeout")))])).rejects.toThrow("Timeout");const x=(await p).value,w=(await u).value;if(!x||x.error||!w||w.error)throw new Error("Error in synchronize");e.expect(x.value.value).toEqual(v),e.expect(x.value.allowed).toEqual(h),e.expect(x.value.channels).toEqual(s),e.expect(w.value.value).toEqual(v),e.expect(w.value.allowed).toEqual([l.actor]),e.expect(w.value.channels).toEqual(i)}))}))};
+//# sourceMappingURL=index.cjs.js.map

package/dist/tests/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/tests/index.js

@@ -0,0 +1,2 @@
+import{assert as e,describe as a,it as t,expect as o}from"vitest";class n extends Error{constructor(e){super(e),this.name="GraffitiErrorForbidden",Object.setPrototypeOf(this,n.prototype)}}class l extends Error{constructor(e){super(e),this.name="GraffitiErrorNotFound",Object.setPrototypeOf(this,l.prototype)}}class s extends Error{constructor(e){super(e),this.name="GraffitiErrorInvalidSchema",Object.setPrototypeOf(this,s.prototype)}}class r extends Error{constructor(e){super(e),this.name="GraffitiErrorSchemaMismatch",Object.setPrototypeOf(this,r.prototype)}}class i extends Error{constructor(e){super(e),this.name="GraffitiErrorPatchTestFailed",Object.setPrototypeOf(this,i.prototype)}}class c extends Error{constructor(e){super(e),this.name="GraffitiErrorPatchError",Object.setPrototypeOf(this,c.prototype)}}class u extends Error{constructor(e){super(e),this.name="GraffitiErrorInvalidUri",Object.setPrototypeOf(this,u.prototype)}}function d(){const e=new Uint8Array(16);return crypto.getRandomValues(e),Array.from(e).map((e=>e.toString(16).padStart(2,"0"))).join("")}function v(){return{value:{[d()]:d()},channels:[d(),d()]}}async function h(a){const t=await a.next();return e(!t.done&&!t.value.error,"result has no value"),t.value.value}const p=e=>{a("URI and location conversion",(()=>{t("location to uri and back",(async()=>{const a=e(),t={name:d(),actor:d(),source:d()},n=a.locationToUri(t),l=a.uriToLocation(n);o(t).toEqual(l)})),t("collision resistance",(async()=>{const a=e(),t={name:d(),actor:d(),source:d()};for(const e of["name","actor","source"]){const n={...t,[e]:d()},l=a.locationToUri(t),s=a.locationToUri(n);o(l).not.toEqual(s)}})),t("random URI should not be a valid location",(async()=>{const a=e();o((()=>a.uriToLocation(""))).toThrow(u)}))}))},w=(e,u,h)=>{a("CRUD",(()=>{t("put, get, delete",(async()=>{const a=e(),t=u(),n={something:"hello, world~ c:"},s=[d(),d()],r=await a.put({value:n,channels:s},t);o(r.value).toEqual({}),o(r.channels).toEqual([]),o(r.allowed).toBeUndefined(),o(r.actor).toEqual(t.actor);const i=await a.get(r,{});o(i.value).toEqual(n),o(i.channels).toEqual([]),o(i.allowed).toBeUndefined(),o(i.name).toEqual(r.name),o(i.actor).toEqual(r.actor),o(i.source).toEqual(r.source),o(i.lastModified).toEqual(r.lastModified);const c={something:"goodbye, world~ :c"},v=await a.put({...r,value:c,channels:[]},t);o(v.value).toEqual(n),o(v.tombstone).toEqual(!0),o(v.name).toEqual(r.name),o(v.actor).toEqual(r.actor),o(v.source).toEqual(r.source),o(v.lastModified).toBeGreaterThan(i.lastModified);const h=await a.get(r,{});o(h.value).toEqual(c),o(h.lastModified).toEqual(v.lastModified),o(h.tombstone).toEqual(!1);const p=await a.delete(h,t);o(p.tombstone).toEqual(!0),o(p.value).toEqual(c),o(p.lastModified).toBeGreaterThan(v.lastModified),await o(a.get(h,{})).rejects.toThrow(l)})),t("put, get, delete with wrong actor",(async()=>{const a=e(),t=u(),l=h();await o(a.put({value:{},channels:[],actor:l.actor},t)).rejects.toThrow(n),await o(a.delete({name:"asdf",source:"asdf",actor:l.actor},t)).rejects.toThrow(n),await o(a.patch({},{name:"asdf",source:"asdf",actor:l.actor},t)).rejects.toThrow(n)})),t("put and get with schema",(async()=>{const a=e(),t=u(),n={something:"hello",another:42},l=await a.put({value:n,channels:[]},t),s=await a.get(l,{properties:{value:{properties:{something:{type:"string"},another:{type:"integer"}}}}});o(s.value.something).toEqual(n.something),o(s.value.another).toEqual(n.another)})),t("put and get with invalid schema",(async()=>{const a=e(),t=u(),n=await a.put({value:{},channels:[]},t);await o(a.get(n,{properties:{value:{type:"asdf"}}})).rejects.toThrow(s)})),t("put and get with wrong schema",(async()=>{const a=e(),t=u(),n=await a.put({value:{hello:"world"},channels:[]},t);await o(a.get(n,{properties:{value:{properties:{hello:{type:"number"}}}}})).rejects.toThrow(r)})),t("put and get with empty access control",(async()=>{const a=e(),t=u(),n=h(),l={um:"hi"},s=[d()],r=[d()],i=await a.put({value:l,allowed:s,channels:r},t),c=await a.get(i,{},t);o(c.value).toEqual(l),o(c.allowed).toEqual(s),o(c.channels).toEqual(r),await o(a.get(i,{})).rejects.toThrow(),await o(a.get(i,{},n)).rejects.toThrow()})),t("put and get with specific access control",(async()=>{const a=e(),t=u(),n=h(),l={um:"hi"},s=[d(),n.actor,d()],r=[d()],i=await a.put({value:l,allowed:s,channels:r},t),c=await a.get(i,{},t);o(c.value).toEqual(l),o(c.allowed).toEqual(s),o(c.channels).toEqual(r),await o(a.get(i,{})).rejects.toThrow();const v=await a.get(i,{},n);o(v.value).toEqual(l),o(v.allowed).toEqual([n.actor]),o(v.channels).toEqual([])})),t("patch value",(async()=>{const a=e(),t=u(),n={something:"hello, world~ c:"},l=await a.put({value:n,channels:[]},t),s=await a.patch({value:[{op:"replace",path:"/something",value:"goodbye, world~ :c"}]},l,t);o(s.value).toEqual(n),o(s.tombstone).toBe(!0);const r=await a.get(l,{});o(r.value).toEqual({something:"goodbye, world~ :c"}),o(s.lastModified).toBe(r.lastModified),await a.delete(l,t)})),t("deep patch",(async()=>{const a=e(),t=u(),n={something:{another:{somethingElse:"hello"}}},l=await a.put({value:n,channels:[]},t),s=await a.patch({value:[{op:"replace",path:"/something/another/somethingElse",value:"goodbye"}]},l,t),r=await a.get(l,{});o(s.value).toEqual(n),o(r.value).toEqual({something:{another:{somethingElse:"goodbye"}}})})),t("patch channels",(async()=>{const a=e(),t=u(),n=[d()],l=[d()],s=await a.put({value:{},channels:n},t),r={channels:[{op:"replace",path:"/0",value:l[0]}]},i=await a.patch(r,s,t);o(i.channels).toEqual(n);const c=await a.get(s,{},t);o(c.channels).toEqual(l),await a.delete(s,t)})),t("patch 'increment' with test",(async()=>{const a=e(),t=u(),n=await a.put({value:{counter:1},channels:[]},t),l=await a.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:2}]},n,t);o(l.value).toEqual({counter:1});const s=await a.get(l,{properties:{value:{properties:{counter:{type:"integer"}}}}});o(s.value.counter).toEqual(2),await o(a.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:3}]},n,t)).rejects.toThrow(i)})),t("invalid patch",(async()=>{const a=e(),t=u(),n=v(),l=await a.put(n,t);await o(a.patch({value:[{op:"add",path:"/root",value:[]},{op:"add",path:"/root/2",value:2}]},l,t)).rejects.toThrow(c)})),t("patch channels to be wrong",(async()=>{const a=e(),t=u(),n=v();n.allowed=[d()];const l=await a.put(n,t),s=[{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 e of s)await o(a.patch(e,l,t)).rejects.toThrow(c);const r=await a.get(l,{},t);o(r.value).toEqual(n.value),o(r.channels).toEqual(n.channels),o(r.allowed).toEqual(n.allowed),o(r.lastModified).toEqual(l.lastModified)}))}))},m=(e,n,l)=>{a("synchronize",(()=>{t("get",(async()=>{const a=e(),t=n(),l=v(),s=l.channels.slice(1),r=await a.put(l,t),i=e(),c=i.synchronize(s,{}).next(),u=await i.get(r,{},t),d=(await c).value;if(!d||d.error)throw new Error("Error in synchronize");o(d.value.value).toEqual(l.value),o(d.value.channels).toEqual(s),o(d.value.tombstone).toBe(!1),o(d.value.lastModified).toEqual(u.lastModified)})),t("put",(async()=>{const a=e(),t=n(),l=d(),s=d(),r=d(),i={hello:"world"},c=[l,r],u=await a.put({value:i,channels:c},t),v=a.synchronize([l],{}).next(),h=a.synchronize([s],{}).next(),p=a.synchronize([r],{}).next(),w={goodbye:"world"},m=[s,r];await a.put({...u,value:w,channels:m},t);const E=(await v).value,f=(await h).value,y=(await p).value;if(!E||E.error||!f||f.error||!y||y.error)throw new Error("Error in synchronize");o(E.value.value).toEqual(i),o(E.value.channels).toEqual([l]),o(E.value.tombstone).toBe(!0),o(f.value.value).toEqual(w),o(f.value.channels).toEqual([s]),o(f.value.tombstone).toBe(!1),o(y.value.value).toEqual(w),o(y.value.channels).toEqual([r]),o(y.value.tombstone).toBe(!1),o(E.value.lastModified).toEqual(f.value.lastModified),o(y.value.lastModified).toEqual(f.value.lastModified)})),t("patch",(async()=>{const a=e(),t=n(),l=d(),s=d(),r=d(),i={hello:"world"},c=[l,r],u=await a.put({value:i,channels:c},t),v=a.synchronize([l],{}).next(),h=a.synchronize([s],{}).next(),p=a.synchronize([r],{}).next();await a.patch({value:[{op:"add",path:"/something",value:"new value"}],channels:[{op:"add",path:"/-",value:s},{op:"remove",path:`/${c.indexOf(l)}`}]},u,t);const w=(await v).value,m=(await h).value,E=(await p).value;if(!w||w.error||!m||m.error||!E||E.error)throw new Error("Error in synchronize");const f={...i,something:"new value"};o(w.value.value).toEqual(i),o(w.value.channels).toEqual([l]),o(w.value.tombstone).toBe(!0),o(m.value.value).toEqual(f),o(m.value.channels).toEqual([s]),o(m.value.tombstone).toBe(!1),o(E.value.value).toEqual(f),o(E.value.channels).toEqual([r]),o(E.value.tombstone).toBe(!1),o(w.value.lastModified).toEqual(m.value.lastModified),o(E.value.lastModified).toEqual(m.value.lastModified)})),t("delete",(async()=>{const a=e(),t=n(),l=[d(),d(),d()],s={hello:"world"},r=[d(),...l.slice(1)],i=await a.put({value:s,channels:r},t),c=a.synchronize(l,{}).next();a.delete(i,t);const u=(await c).value;if(!u||u.error)throw new Error("Error in synchronize");o(u.value.tombstone).toBe(!0),o(u.value.value).toEqual(s),o(u.value.channels).toEqual(l.filter((e=>r.includes(e))))})),t("not allowed",(async()=>{const a=e(),t=n(),s=l(),r=[d(),d(),d()],i=r.slice(1),c=a.synchronize(i,{},t).next(),u=a.synchronize(i,{},s).next(),v=a.synchronize(i,{}).next(),h={hello:"world"},p=[d(),s.actor];await a.put({value:h,channels:r,allowed:p},t),await o(Promise.race([v,new Promise(((e,a)=>setTimeout(a,100,"Timeout")))])).rejects.toThrow("Timeout");const w=(await c).value,m=(await u).value;if(!w||w.error||!m||m.error)throw new Error("Error in synchronize");o(w.value.value).toEqual(h),o(w.value.allowed).toEqual(p),o(w.value.channels).toEqual(r),o(m.value.value).toEqual(h),o(m.value.allowed).toEqual([s.actor]),o(m.value.channels).toEqual(i)}))}))},E=(n,l,s)=>{a("discover",(()=>{t("discover nothing",(async()=>{const e=n().discover([],{});o(await e.next()).toHaveProperty("done",!0)})),t("discover single",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a),r=[d(),t.channels[0]],i=e.discover(r,{}),c=await h(i);o(c.value).toEqual(t.value),o(c.channels).toEqual([t.channels[0]]),o(c.allowed).toBeUndefined(),o(c.actor).toEqual(a.actor),o(c.tombstone).toBe(!1),o(c.lastModified).toEqual(s.lastModified);const u=await i.next();o(u.done).toBe(!0)})),t("discover wrong channel",(async()=>{const e=n(),a=l(),t=v();await e.put(t,a);const s=e.discover([d()],{});await o(s.next()).resolves.toHaveProperty("done",!0)})),t("discover not allowed",(async()=>{const e=n(),a=l(),t=s(),r=v();r.allowed=[d(),d()];const i=await e.put(r,a),c=e.discover(r.channels,{},a),u=await h(c);o(u.value).toEqual(r.value),o(u.channels).toEqual(r.channels),o(u.allowed).toEqual(r.allowed),o(u.actor).toEqual(a.actor),o(u.tombstone).toBe(!1),o(u.lastModified).toEqual(i.lastModified);const p=e.discover(r.channels,{},t);o(await p.next()).toHaveProperty("done",!0);const w=e.discover(r.channels,{});o(await w.next()).toHaveProperty("done",!0)})),t("discover allowed",(async()=>{const e=n(),a=l(),t=s(),r=v();r.allowed=[d(),t.actor,d()];const i=await e.put(r,a),c=e.discover(r.channels,{},t),u=await h(c);o(u.value).toEqual(r.value),o(u.allowed).toEqual([t.actor]),o(u.channels).toEqual(r.channels),o(u.actor).toEqual(a.actor),o(u.tombstone).toBe(!1),o(u.lastModified).toEqual(i.lastModified)}));for(const e of["name","actor","lastModified"])t(`discover for ${e}`,(async()=>{const a=n(),t=l(),r=s(),i=v(),c=await a.put(i,t),u=v();u.channels=i.channels,await new Promise((e=>setTimeout(e,20)));const d=await a.put(u,r),p=a.discover(i.channels,{properties:{[e]:{enum:[c[e]]}}}),w=await h(p);o(w.name).toEqual(c.name),o(w.name).not.toEqual(d.name),o(w.value).toEqual(i.value),await o(p.next()).resolves.toHaveProperty("done",!0)}));t("discover with lastModified range",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a);await new Promise((e=>setTimeout(e,20)));const r=await e.put(t,a);o(s.name).not.toEqual(r.name),o(s.lastModified).toBeLessThan(r.lastModified);const i=e.discover([t.channels[0]],{properties:{lastModified:{minimum:r.lastModified,exclusiveMinimum:!0}}});o(await i.next()).toHaveProperty("done",!0);const c=e.discover([t.channels[0]],{properties:{lastModified:{minimum:r.lastModified-.1,exclusiveMinimum:!0}}}),u=await h(c);o(u.name).toEqual(r.name),o(await c.next()).toHaveProperty("done",!0);const d=e.discover(t.channels,{properties:{value:{},lastModified:{minimum:r.lastModified}}}),p=await h(d);o(p.name).toEqual(r.name),o(await d.next()).toHaveProperty("done",!0);const w=e.discover(t.channels,{properties:{lastModified:{minimum:r.lastModified+.1}}});o(await w.next()).toHaveProperty("done",!0);const m=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified,exclusiveMaximum:!0}}});o(await m.next()).toHaveProperty("done",!0);const E=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified+.1,exclusiveMaximum:!0}}}),f=await h(E);o(f.name).toEqual(s.name),o(await E.next()).toHaveProperty("done",!0);const y=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified}}}),q=await h(y);o(q.name).toEqual(s.name),o(await y.next()).toHaveProperty("done",!0);const g=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified-.1}}});o(await g.next()).toHaveProperty("done",!0)})),t("discover schema allowed, as and not as owner",(async()=>{const e=n(),a=l(),t=s(),r=v();r.allowed=[d(),t.actor,d()],await e.put(r,a);const i=e.discover(r.channels,{properties:{allowed:{minItems:3,not:{items:{not:{enum:[t.actor]}}}}}},a),c=await h(i);o(c.value).toEqual(r.value),await o(i.next()).resolves.toHaveProperty("done",!0);const u=e.discover(r.channels,{properties:{allowed:{minItems:3}}},t);await o(u.next()).resolves.toHaveProperty("done",!0);const p=e.discover(r.channels,{properties:{allowed:{not:{items:{not:{enum:[r.channels[0]]}}}}}},t);await o(p.next()).resolves.toHaveProperty("done",!0);const w=e.discover(r.channels,{properties:{allowed:{maxItems:1,not:{items:{not:{enum:[t.actor]}}}}}},t),m=await h(w);o(m.value).toEqual(r.value),await o(w.next()).resolves.toHaveProperty("done",!0)})),t("discover schema channels, as and not as owner",(async()=>{const e=n(),a=l(),t=s(),r=v();r.channels=[d(),d(),d()],await e.put(r,a);const i=e.discover([r.channels[0],r.channels[2]],{properties:{channels:{minItems:3,not:{items:{not:{enum:[r.channels[1]]}}}}}},a),c=await h(i);o(c.value).toEqual(r.value),await o(i.next()).resolves.toHaveProperty("done",!0);const u=e.discover([r.channels[0],r.channels[2]],{properties:{channels:{minItems:3}}},t);await o(u.next()).resolves.toHaveProperty("done",!0);const p=e.discover([r.channels[0],r.channels[2]],{properties:{channels:{not:{items:{not:{enum:[r.channels[1]]}}}}}},t);await o(p.next()).resolves.toHaveProperty("done",!0);const w=e.discover([r.channels[0],r.channels[2]],{properties:{allowed:{maxItems:2,not:{items:{not:{enum:[r.channels[2]]}}}}}},t),m=await h(w);o(m.value).toEqual(r.value),await o(w.next()).resolves.toHaveProperty("done",!0)})),t("discover query for empty allowed",(async()=>{const e=n(),a=l(),t=v(),s={not:{required:["allowed"]}};await e.put(t,a);const r=e.discover(t.channels,s,a),i=await h(r);o(i.value).toEqual(t.value),o(i.allowed).toBeUndefined(),await o(r.next()).resolves.toHaveProperty("done",!0);const c=v();c.allowed=[],await e.put(c,a);const u=e.discover(c.channels,s,a);await o(u.next()).resolves.toHaveProperty("done",!0)})),t("discover query for values",(async()=>{const a=n(),t=l(),s=v();s.value={test:d()},await a.put(s,t);const r=v();r.channels=s.channels,r.value={test:d(),something:d()},await a.put(r,t);const i=v();i.channels=s.channels,i.value={other:d(),something:d()},await a.put(i,t);const c=new Map;for(const t of["test","something","other"]){let o=0;for await(const n of a.discover(s.channels,{properties:{value:{required:[t]}}}))e(!n.error,"result has error"),t in n.value.value&&o++;c.set(t,o)}o(c.get("test")).toBe(2),o(c.get("something")).toBe(2),o(c.get("other")).toBe(1)})),t("discover for deleted content",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a),r=await e.delete(s,a),i=e.discover(t.channels,{}),c=await h(i);o(c.tombstone).toBe(!0),o(c.value).toEqual(t.value),o(c.channels).toEqual(t.channels),o(c.actor).toEqual(a.actor),o(c.lastModified).toEqual(r.lastModified),await o(i.next()).resolves.toHaveProperty("done",!0)})),t("discover for replaced channels",(async()=>{for(let e=0;e<10;e++){const e=n(),a=l(),t=v(),s=await e.put(t,a),r=v(),i=await e.put({...s,...r},a),c=e.discover(t.channels,{}),u=await h(c);await o(c.next()).resolves.toHaveProperty("done",!0);const d=e.discover(r.channels,{}),p=await h(d);await o(d.next()).resolves.toHaveProperty("done",!0),s.lastModified===i.lastModified?(o(u.tombstone||p.tombstone).toBe(!0),o(u.tombstone&&p.tombstone).toBe(!1)):(o(u.tombstone).toBe(!0),o(u.value).toEqual(t.value),o(u.channels).toEqual(t.channels),o(u.lastModified).toEqual(i.lastModified),o(p.tombstone).toBe(!1),o(p.value).toEqual(r.value),o(p.channels).toEqual(r.channels),o(p.lastModified).toEqual(i.lastModified))}})),t("discover for patched allowed",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a);await e.patch({allowed:[{op:"add",path:"",value:[]}]},s,a);const r=e.discover(t.channels,{}),i=await h(r);o(i.tombstone).toBe(!0),o(i.value).toEqual(t.value),o(i.channels).toEqual(t.channels),o(i.allowed).toBeUndefined(),await o(r.next()).resolves.toHaveProperty("done",!0)})),t("put concurrently and discover one",(async()=>{const a=n(),t=l(),s=v();s.name=d();const r=Array(100).fill(0).map((()=>a.put(s,t)));await Promise.all(r);const i=a.discover(s.channels,{});let c=0,u=0;for await(const a of i)e(!a.error,"result has error"),a.value.tombstone?c++:u++;o(c).toBe(99),o(u).toBe(1)}))}))};export{w as graffitiCRUDTests,E as graffitiDiscoverTests,p as graffitiLocationTests,m as graffitiSynchronizeTests};
+//# sourceMappingURL=index.js.map

package/dist/tests/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types/src/1-api.d.ts

@@ -0,0 +1,638 @@
+import type { GraffitiLocation, GraffitiObject, GraffitiObjectBase, GraffitiPatch, GraffitiSession, GraffitiPutObject, GraffitiStream } from "./2-types";
+import type { JSONSchema4 } from "json-schema";
+/**
+ * This API describes a small but powerful set of methods that
+ * can be used to create many different kinds of social media applications,
+ * all of which can interoperate.
+ * These methods should satisfy all of an application's needs for
+ * the communication, storage, and access management of social data.
+ * The rest of the application can be built with standard client-side
+ * user interface tools to present and interact with the data —
+ * no server code necessary.
+ * The Typescript source for this API is available at
+ * [graffiti-garden/api](https://github.com/graffiti-garden/api).
+ *
+ * There are several different implementations of this Graffiti API available,
+ * including a [decentralized implementation](https://github.com/graffiti-garden/client-core),
+ * and a [local implementation](https://github.com/graffiti-garden/implementation-pouchdb)
+ * that can be used for testing. In our design of Graffiti, this API is our
+ * primary focus as it is the layer that shapes the experience
+ * of developing applications. While different implementations can provide tradeoffs between
+ * other important properties (e.g. privacy, security, scalability), those properties
+ * are useless if the system as a whole doesn't expose useful functionality to developers.
+ *
+ * On the other side of the stack, there is [Vue plugin](https://github.com/graffiti-garden/wrapper-vue/)
+ * that wraps around this API to provide reactivity. Other high-level libraries
+ * will be available in the future.
+ *
+ * ## Overview
+ *
+ * This API tries to draw from well-known concepts and standards wherever possible.
+ * JSON objects, representing social artifacts (e.g. posts, profiles) and activities
+ * (e.g. likes, follows) can be interacted with through standard CRUD operations:
+ *  {@link put}, {@link get}, {@link patch}, and {@link delete}.
+ * Objects can be typed with [JSON Schema](https://json-schema.org/) and patches
+ * can be applied with [JSON Patch](https://jsonpatch.com).
+ * For interoperability between Graffiti applications, we recommend using established properties from the
+ * [Activity Vocabulary](https://www.w3.org/TR/activitystreams-vocabulary/) when available.
+ *
+ * The social aspect of Graffiti comes from the {@link discover} operation
+ * which allows applications to find objects that other users made.
+ * It is a lot like a traditional query operation, but it only
+ * returns objects that have been placed in particular
+ * {@link GraffitiObjectBase.channels | `channels`}
+ * specified by the discovering application.
+ *
+ * {@link GraffitiObjectBase.channels | `channels`} are one of the major concepts
+ * unique to Graffiti along with *interaction relativity*.
+ * Channels create boundaries between public spaces and work to prevent
+ * [context collapse](https://en.wikipedia.org/wiki/Context_collapse)
+ * even in a highly interoperable environment.
+ * Interaction relativity means that all interactions between users are
+ * actually atomic single-user operations that can be interpreted in different ways,
+ * which also supports interoperability and pluralism.
+ *
+ * ### Channels
+ *
+ * {@link GraffitiObjectBase.channels | `channels`}
+ * are a way for the creators of social data to express the intended audience of their
+ * data. When a user creates data using the {@link put} method, they
+ * can place their data in one or more channels.
+ * Content consumers using the {@link discover} method will only see data
+ * contained in one of the channels they specify.
+ *
+ * While many channels may be public, they partition
+ * the public into different "contexts", mitigating the
+ * phenomenon of [context collapse](https://en.wikipedia.org/wiki/Context_collapse) or the "flattening of multiple audiences."
+ * Any [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) can be used as a channel, and so channels can represent people,
+ * comment threads, topics, places (real or virtual), pieces of media, and more.
+ *
+ * For example, consider a comment on a post. If we place that comment in the channel
+ * represented by the post's URI, then only people viewing the post will know to
+ * look in that channel, giving it visibility akin to a comment on a blog post
+ * or comment on Instagram ([since 2019](https://www.buzzfeednews.com/article/katienotopoulos/instagrams-following-activity-tab-is-going-away)).
+ * If we also place the comment in the channel represented by the commenter's URI (their
+ * {@link GraffitiObjectBase.actor | `actor` URI}), then people viewing the commenter's profile
+ * will also see the comment, giving it more visibility, like a reply on Twitter.
+ * If we *only* place the comment in the channel represented by the commenter's URI, then
+ * it becomes like a quote tweet ([prior to 2020](https://x.com/Support/status/1300555325750292480)),
+ * where the comment is only visible to the commenter's followers but not the audience
+ * of the original post.
+ *
+ * The channel model differs from other models of communication such as the
+ * [actor model](https://www.w3.org/TR/activitypub/#Overview) used by ActivityPub,
+ * the protocol underlying Mastodon, or the [firehose model](https://bsky.social/about/blog/5-5-2023-federation-architecture)
+ * used by the AT Protocol, the protocol underlying BlueSky.
+ * The actor model is a fusion of direct messaging (like Email) and broadcasting
+ * (like RSS) and works well for follow-based communication but struggles
+ * to pass information via other rendez-vous.
+ * In the actor model, even something as simple as comments can be
+ * [very tricky and require server "side effects"](https://seb.jambor.dev/posts/understanding-activitypub-part-3-the-state-of-mastodon/).
+ * The firehose model dumps all user data into one public database,
+ * which doesn't allow for the carving out of different contexts that we did in our comment
+ * example above. In the firehose model a comment will always be visible to *both* the original post's audience and
+ * the commenter's followers.
+ *
+ * In some sense, channels provide a sort of "social access control" by forming
+ * expectations about the audiences of different online spaces.
+ * As a real world analogy, oftentimes support groups, such as alcoholics
+ * anonymous, are open to the public but people in those spaces feel comfortable sharing intimate details
+ * because they have expectations about the other people attending.
+ * If someone malicious went to support groups just to spread people's secrets,
+ * they would be shamed for violating these norms.
+ * Similarly, in Graffiti, while you could spider public channels like a search engine
+ * to find content about a person, revealing that you've done such a thing
+ * would be shameful.
+ *
+ * Still, social access control is not perfect and so in situations where privacy is important,
+ * objects can also be given
+ * an {@link GraffitiObjectBase.allowed | `allowed`} list.
+ * For example, to send someone a direct message you should put an object representing
+ * that message in the channel that represents them (their {@link GraffitiObjectBase.actor | `actor` URI}),
+ * so they can find it, *and* set the `allowed` field to only include the recipient,
+ * so only they can read it.
+ *
+ * ### Interaction relativity
+ *
+ * Interaction relativity posits that "interaction between two individuals only
+ * exists relative to an observer," or equivalently, all interaction is [reified](https://en.wikipedia.org/wiki/Reification_(computer_science)).
+ * For example, if one user creates a post and another user wants to "like" that post,
+ * their like is not modifying the original post, it is simply another data object that points
+ * to the post being liked, via its {@link locationToUri | URI}.
+ *
+ * ```json
+ * {
+ *   activity: 'like',
+ *   target: 'uri-of-the-post-i-like',
+ *   actor: 'my-user-id'
+ * }
+ * ```
+ *
+ * In Graffiti, all interactions including *moderation* and *collaboration* are relative.
+ * This means that applications can freely choose which interactions
+ * they want to express to their users and how.
+ * For example, one application could have a single fixed moderator,
+ * another could allow users to choose which moderators they would like filter their content
+ * like [Bluesky's stackable moderation](https://bsky.social/about/blog/03-12-2024-stackable-moderation),
+ * and another could implement a fully democratic system like [PolicyKit](https://policykit.org/).
+ * Each of these applications is one interpretation of the underlying refieid user interactions and
+ * users can freely switch between them.
+ *
+ * Interaction relativy also allows applications to introduce new sorts of interactions
+ * without having to coordinate with all the other existing applications,
+ * keeping the ecosystem flexible and interoperable.
+ * For example, an application could [add a "Trust" button to posts](https://social.cs.washington.edu/pub_details.html?id=trustnet)
+ * and use it assess the truthfulness of posts made on applications across Graffiti.
+ * New sorts of interactions like these can be smoothly absorbed by the broader ecosystem
+ * as a [folksonomy](https://en.wikipedia.org/wiki/Folksonomy).
+ *
+ * Interactivy relativity is realized in Graffiti through two design decisions:
+ * 1. The creators of objects can only modify their own objects. It is important for
+ *    users to be able to change and delete their own content to respect their
+ *    [right to be forgotten](https://en.wikipedia.org/wiki/Right_to_be_forgotten),
+ *    but beyond self-correction and self-censorship all other interaction is reified.
+ *    Many interactions can be reified via pointers, as in the "like" example above, and collaborative
+ *    edits can be refieid via [CRDTs](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type).
+ * 2. No one owns channels. Unlike IRC/Slack channels or [Matrix rooms](https://matrix.org/docs/matrix-concepts/rooms_and_events/),
+ *    anyone can post to any channel, so long as they know the URI of that channel.
+ *    It is up to applications to hide content from channels either according to manual
+ *    filters or in response to user action.
+ *    For example, a user may create a post with the flag `disableReplies`.
+ *    Applications could then filter out any content from the replies channel
+ *    that the original poster has not specifically approved.
+ *
+ * ## Implementing the API
+ *
+ * To implement the API, first install it:
+ *
+ * ```bash
+ * npm install @graffiti-garden/api
+ * ```
+ *
+ * Then create a class that extends the `Graffiti` class and implement the abstract methods.
+ *
+ * ```typescript
+ * import { Graffiti } from "@graffiti-garden/api";
+ *
+ * class MyGraffitiImplementation extends Graffiti {
+ *   // Implement the abstract methods here
+ * }
+ * ```
+ * ### Testing
+ *
+ * We have written a number of unit tests written with [vitest](https://vitest.dev/)
+ * that can be used to verify implementations of the API.
+ * To use them, create a test file in that ends in `*.spec.ts` and format it as follows:
+ *
+ * ```typescript
+ * import { graffitiCRUDTests } from "@graffiti-garden/api/tests";
+ *
+ * const useGraffiti = () => new MyGraffitiImplementation();
+ * // Fill in with implementation-specific information
+ * // to provide to valid actor sessions for the tests
+ * // to use as identities.
+ * const useSession1 = () => ({ actor: "someone" });
+ * const useSession2 = () => ({ actor: "someoneelse" });
+ *
+ * // Run the tests
+ * graffitiCRUDTests(useGraffiti, useSession1, useSession2);
+ * ```
+ *
+ * Then run the tests in the root of your directory with:
+ *
+ * ```bash
+ * npx vitest
+ * ```
+ *
+ * ## Building the Documentation
+ *
+ * To build the [TypeDoc](https://typedoc.org/) documentation, run the following commands:
+ *
+ * ```bash
+ * npm run install
+ * npm run docs
+ * ```
+ *
+ * Then run a local server to view the documentation:
+ *
+ * ```bash
+ * cd docs
+ * npx http-server
+ * ```
+ *
+ * ## TODO
+ *
+ * - Test for listChannels and listOrphans,
+ * - Implement scope.
+ *
+ * @groupDescription CRUD Methods
+ * Methods for {@link put | creating}, {@link get | reading}, {@link patch | updating},
+ * and {@link delete | deleting} {@link GraffitiObjectBase | Graffiti objects}.
+ * @groupDescription Query Methods
+ * Methods for retrieving multiple {@link GraffitiObjectBase | Graffiti objects} at a time.
+ * @groupDescription Session Management
+ * Methods and properties for logging in and out of a Graffiti implementation.
+ * @groupDescription Utilities
+ * Methods for for converting Graffiti objects to and from URIs
+ * and for finding lost objects.
+ */
+export declare abstract class Graffiti {
+    /**
+     * Converts a {@link GraffitiLocation} object containing a
+     * {@link GraffitiObjectBase.name | `name`}, {@link GraffitiObjectBase.actor | `actor`},
+     * and {@link GraffitiObjectBase.source | `source`} into a globally unique URI.
+     * The form of this URI is implementation dependent.
+     *
+     * Its exact inverse is {@link uriToLocation}.
+     *
+     * @group Utilities
+     */
+    abstract locationToUri(location: GraffitiLocation): string;
+    /**
+     * Parses a globally unique Graffiti URI into a {@link GraffitiLocation}
+     * object containing a {@link GraffitiObjectBase.name | `name`},
+     * {@link GraffitiObjectBase.actor | `actor`}, and {@link GraffitiObjectBase.source | `source`}.
+     *
+     * Its exact inverse is {@link locationToUri}.
+     *
+     * @group Utilities
+     */
+    abstract uriToLocation(uri: string): GraffitiLocation;
+    /**
+     * An alias of {@link locationToUri}
+     *
+     * @group Utilities
+     */
+    objectToUri(object: GraffitiObjectBase): string;
+    /**
+     * Creates a new {@link GraffitiObjectBase | object} or replaces an existing object.
+     * An object can only be replaced by the same {@link GraffitiObjectBase.actor | `actor`}
+     * that created it.
+     *
+     * Replacement occurs when the {@link GraffitiLocation} properties of the supplied object
+     * ({@link GraffitiObjectBase.name | `name`}, {@link GraffitiObjectBase.actor | `actor`},
+     * and {@link GraffitiObjectBase.source | `source`}) exactly match the location of an existing object.
+     *
+     * @returns The object that was replaced if one exists or an object with
+     * with a `null` {@link GraffitiObjectBase.value | `value`} if this method
+     * created a new object.
+     * The object will have a {@link GraffitiObjectBase.tombstone | `tombstone`}
+     * field set to `true` and a {@link GraffitiObjectBase.lastModified | `lastModified`}
+     * field updated to the time of replacement/creation.
+     *
+     * @group CRUD Methods
+     */
+    abstract put<Schema>(
+    /**
+     * The object to be put. This object is statically type-checked against the [JSON schema](https://json-schema.org/) that can be optionally provided
+     * as the generic type parameter. We highly recommend providing a schema to
+     * ensure that the PUT object matches subsequent {@link get} or {@link discover}
+     * methods.
+     */
+    object: GraffitiPutObject<Schema>, 
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}.
+     */
+    session: GraffitiSession): Promise<GraffitiObjectBase>;
+    /**
+     * Retrieves an object from a given location.
+     * If no object exists at that location or if the retrieving
+     * {@link GraffitiObjectBase.actor | `actor`} is not the creator or included in
+     * the object's {@link GraffitiObjectBase.allowed | `allowed`} property,
+     * a {@link GraffitiErrorNotFound} is thrown.
+     *
+     * The retrieved object is also type-checked against the provided [JSON schema](https://json-schema.org/)
+     * otherwise a {@link GraffitiErrorSchemaMismatch} is thrown.
+     *
+     * @group CRUD Methods
+     */
+    abstract get<Schema extends JSONSchema4>(
+    /**
+     * The location of the object to get.
+     */
+    locationOrUri: GraffitiLocation | string, 
+    /**
+     * The JSON schema to validate the retrieved object against.
+     */
+    schema: Schema, 
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
+     * the retrieved object's {@link GraffitiObjectBase.allowed | `allowed`}
+     * property must be `undefined`.
+     */
+    session?: GraffitiSession): Promise<GraffitiObject<Schema>>;
+    /**
+     * Patches an existing object at a given location.
+     * The patching {@link GraffitiObjectBase.actor | `actor`} must be the same as the
+     * `actor` that created the object.
+     *
+     * @returns The object that was deleted if one exists or an object with
+     * with a `null` {@link GraffitiObjectBase.value | `value`} otherwise.
+     * The object will have a {@link GraffitiObjectBase.tombstone | `tombstone`}
+     * field set to `true` and a {@link GraffitiObjectBase.lastModified | `lastModified`}
+     * field updated to the time of deletion.
+     *
+     * @group CRUD Methods
+     */
+    abstract patch(
+    /**
+     * A collection of [JSON Patch](https://jsonpatch.com) operations
+     * to apply to the object. See {@link GraffitiPatch} for more information.
+     */
+    patch: GraffitiPatch, 
+    /**
+     * The location of the object to patch.
+     */
+    locationOrUri: GraffitiLocation | string, 
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}.
+     */
+    session: GraffitiSession): Promise<GraffitiObjectBase>;
+    /**
+     * Deletes an object from a given location.
+     * The deleting {@link GraffitiObjectBase.actor | `actor`} must be the same as the
+     * `actor` that created the object.
+     *
+     * If the object does not exist or has already been deleted,
+     * {@link GraffitiErrorNotFound} is thrown.
+     *
+     * @returns The object that was deleted if one exists or an object with
+     * with a `null` {@link GraffitiObjectBase.value | `value`} otherwise.
+     * The object will have a {@link GraffitiObjectBase.tombstone | `tombstone`}
+     * field set to `true` and a {@link GraffitiObjectBase.lastModified | `lastModified`}
+     * field updated to the time of deletion.
+     *
+     * @group CRUD Methods
+     */
+    abstract delete(
+    /**
+     * The location of the object to delete.
+     */
+    locationOrUri: GraffitiLocation | string, 
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}.
+     */
+    session: GraffitiSession): Promise<GraffitiObjectBase>;
+    /**
+     * Discovers objects created by any user that are contained
+     * in at least one of the given {@link GraffitiObjectBase.channels | `channels`}
+     * and match the given [JSON Schema](https://json-schema.org).
+     *
+     * Objects are returned asynchronously as they are discovered but the stream
+     * will end once all leads have been exhausted.
+     * The method must be polled again for new objects.
+     *
+     * `discover` will not return objects that the {@link GraffitiObjectBase.actor | `actor`}
+     * is not {@link GraffitiObjectBase.allowed | `allowed`} to access.
+     * If the actor is not the creator of a discovered object,
+     * the allowed list will be masked to only contain the querying actor if the
+     * allowed list is not `undefined` (public). Additionally, if the actor is not the
+     * creator of a discovered object, any {@link GraffitiObjectBase.channels | `channels`}
+     * not specified by the `discover` method will not be revealed. This masking happens
+     * before the supplied schema is applied.
+     *
+     * {@link discover} can be used in conjunction with {@link synchronize}
+     * to provide a responsive and consistent user experience.
+     *
+     * Since different implementations may fetch data from multiple sources there is
+     * no guarentee on the order that objects are returned in. Additionally, the method
+     * will return objects that have been deleted but with a
+     * {@link GraffitiObjectBase.tombstone | `tombstone`} field set to `true` for
+     * cache invalidation purposes.
+     * The final `return()` value of the stream includes a `tombstoneRetention`
+     * property that represents the minimum amount of time,
+     * in milliseconds, that an application will retain and return tombstones for objects that
+     * have been deleted.
+     *
+     * When repolling, the {@link GraffitiObjectBase.lastModified | `lastModified`}
+     * field can be queried via the schema to
+     * only fetch objects that have been modified since the last poll.
+     * Such queries should only be done if the time since the last poll
+     * is less than the `tombstoneRetention` value of that poll, otherwise the tombstones
+     * for objects that have been deleted may not be returned.
+     *
+     * ```json
+     * {
+     *   "properties": {
+     *     "lastModified": {
+     *       "minimum": LAST_RETRIEVED_TIME
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * `discover` needs to be polled for new data because live updates to
+     * an application can be visually distracting or lead to toxic engagement.
+     * If and when an application wants real-time updates, such as in a chat
+     * application, application authors must be intentional about their polling.
+     *
+     * Implementers should be aware that some users may applications may try to poll
+     * {@link discover} repetitively. You can deal with this by rate limiting or
+     * preemptively fetching data via a bidirectional channel, like a WebSocket.
+     * Additionally, implementers should probably index the `lastModified` field
+     * to speed up responses to schemas like the one above.
+     *
+     * @returns A stream of objects that match the given {@link GraffitiObjectBase.channels | `channels`}
+     * and [JSON Schema](https://json-schema.org).
+     *
+     * @group Query Methods
+     */
+    abstract discover<Schema extends JSONSchema4>(
+    /**
+     * The {@link GraffitiObjectBase.channels | `channels`} that objects must be associated with.
+     */
+    channels: string[], 
+    /**
+     * A [JSON Schema](https://json-schema.org) that objects must satisfy.
+     */
+    schema: Schema, 
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
+     * only objects that have no {@link GraffitiObjectBase.allowed | `allowed`}
+     * property will be returned.
+     */
+    session?: GraffitiSession): GraffitiStream<GraffitiObject<Schema>, {
+        tombstoneRetention: number;
+    }>;
+    /**
+     * This method has the same signature as {@link discover} but listens for
+     * changes made via {@link put}, {@link patch}, and {@link delete} or
+     * fetched from {@link get} or {@link discover} and then streams appropriate
+     * changes to provide a responsive and consistent user experience.
+     *
+     * Unlike {@link discover}, this method continuously listens for changes
+     * and will not terminate unless the user calls the `return` method on the iterator
+     * or `break`s out of the loop.
+     *
+     * Example 1: Suppose a user publishes a post using {@link put}. If the feed
+     * displaying that user's posts is using {@link synchronize} to listen for changes,
+     * then the user's new post will instantly appear in their feed, giving the UI a
+     * responsive feel.
+     *
+     * Example 2: Suppose one of a user's friends changes their name. As soon as the
+     * user's application receives one notice of that change (using {@link get}
+     * or {@link discover}), then {@link synchronize} listeners can be used to update
+     * all instance's of that friend's name in the user's application instantly,
+     * providing a consistent user experience.
+     *
+     * @group Query Methods
+     */
+    abstract synchronize<Schema extends JSONSchema4>(
+    /**
+     * The {@link GraffitiObjectBase.channels | `channels`} that the objects must be associated with.
+     */
+    channels: string[], 
+    /**
+     * A [JSON Schema](https://json-schema.org) that objects must satisfy.
+     */
+    schema: Schema, 
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
+     * only objects that have no {@link GraffitiObjectBase.allowed | `allowed`}
+     * property will be returned.
+     */
+    session?: GraffitiSession): GraffitiStream<GraffitiObject<Schema>>;
+    /**
+     * Returns a list of all {@link GraffitiObjectBase.channels | `channels`}
+     * that an {@link GraffitiObjectBase.actor | `actor`} has posted to.
+     * This is not very useful for most applications, but
+     * necessary for certain applications where a user wants a
+     * global view of all their Graffiti data or to debug
+     * channel usage.
+     *
+     * @group Utilities
+     *
+     * @returns A stream the {@link GraffitiObjectBase.channels | `channel`}s
+     * that the {@link GraffitiObjectBase.actor | `actor`} has posted to.
+     * The `lastModified` field is the time that the user last modified an
+     * object in that channel. The `count` field is the number of objects
+     * that the user has posted to that channel.
+     */
+    abstract listChannels(
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}.
+     */
+    session: GraffitiSession): GraffitiStream<{
+        channel: string;
+        lastModified: number;
+        count: number;
+    }>;
+    /**
+     * Returns a list of all {@link GraffitiObjectBase | objects} a user has posted that are
+     * not associated with any {@link GraffitiObjectBase.channels | `channel`}, i.e. orphaned objects.
+     * This is not very useful for most applications, but
+     * necessary for certain applications where a user wants a
+     * global view of all their Graffiti data or to debug
+     * channel usage.
+     *
+     * @group Utilities
+     *
+     * @returns A stream of the {@link GraffitiObjectBase.name | `name`}
+     * and {@link GraffitiObjectBase.source | `source`} of the orphaned objects
+     * that the {@link GraffitiObjectBase.actor | `actor`} has posted to.
+     * The {@link GraffitiObjectBase.lastModified | lastModified} field is the
+     * time that the user last modified the orphan.
+     */
+    abstract listOrphans(session: GraffitiSession): GraffitiStream<{
+        name: string;
+        source: string;
+        lastModified: string;
+    }>;
+    /**
+     * The age at which a query for a session will be considered expired.
+     */
+    /**
+     * Begins the login process. Depending on the implementation, this may
+     * involve redirecting the user to a login page or opening a popup,
+     * so it should always be called in response to a user action.
+     *
+     * The {@link GraffitiSession | session} object is returned
+     * asynchronously via {@link Graffiti.sessionEvents | sessionEvents}
+     * as a {@link GraffitiLoginEvent} with event type `login`.
+     *
+     * @group Session Management
+     */
+    abstract login(
+    /**
+     * Suggestions for the permissions that the
+     * login process should grant. The login process may not
+     * provide the exact proposed permissions.
+     */
+    proposal?: {
+        /**
+         * A suggested actor to login as. For example, if a user tries to
+         * edit a post but are not logged in, the interface can infer that
+         * they might want to log in as the actor who created the post
+         * they are attempting to edit.
+         *
+         * Even if provided, the implementation should allow the user
+         * to log in as a different actor if they choose.
+         */
+        actor?: string;
+        /**
+         * A yet to be defined permissions scope. An application may use
+         * this to indicate the minimum necessary scope needed to
+         * operate. For example, it may need to be able read private
+         * messages from a certain set of channels, or write messages that
+         * follow a particular schema.
+         *
+         * The login process should make it clear what scope an application
+         * is requesting and allow the user to enhance or reduce that
+         * scope as necessary.
+         */
+        scope?: {};
+    }, 
+    /**
+     * An arbitrary string that will be returned with the
+     * {@link GraffitiSession | session} object
+     * when the login process is complete.
+     * See {@link GraffitiLoginEvent}.
+     */
+    state?: string): Promise<void>;
+    /**
+     * Begins the logout process. Depending on the implementation, this may
+     * involve redirecting the user to a logout page or opening a popup,
+     * so it should always be called in response to a user action.
+     *
+     * A confirmation will be returned asynchronously via
+     * {@link Graffiti.sessionEvents | sessionEvents}
+     * as a {@link GraffitiLogoutEvent} as event type `logout`.
+     *
+     * @group Session Management
+     */
+    abstract logout(
+    /**
+     * The {@link GraffitiSession | session} object to logout.
+     */
+    session: GraffitiSession, 
+    /**
+     * An arbitrary string that will be returned with the
+     * when the logout process is complete.
+     * See {@link GraffitiLogoutEvent}.
+     */
+    state?: string): Promise<void>;
+    /**
+     * An event target that can be used to listen for `login`
+     * and `logout` events. They are custom events of types
+     * {@link GraffitiLoginEvent} and {@link GraffitiLogoutEvent }
+     * respectively.
+     *
+     * @group Session Management
+     */
+    abstract readonly sessionEvents: EventTarget;
+}
+/**
+ * This is a factory function that produces an instance of
+ * the {@link Graffiti} class. Since the Graffiti class is
+ * abstract, factory functions provide an easy way to
+ * swap out different implementations.
+ */
+export type GraffitiFactory = () => Graffiti;
+//# sourceMappingURL=1-api.d.ts.map

package/dist/types/src/1-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1-api.d.ts","sourceRoot":"","sources":["../../../src/1-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,cAAc,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2OG;AACH,8BAAsB,QAAQ;IAC5B;;;;;;;;;OASG;IACH,QAAQ,CAAC,aAAa,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM;IAE1D;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB;IAErD;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,kBAAkB;IAItC;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,GAAG,CAAC,MAAM;IACjB;;;;;OAKG;IACH,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC;IACjC;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC;IAE9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,GAAG,CAAC,MAAM,SAAS,WAAW;IACrC;;OAEG;IACH,aAAa,EAAE,gBAAgB,GAAG,MAAM;IACxC;;OAEG;IACH,MAAM,EAAE,MAAM;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAElC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK;IACZ;;;OAGG;IACH,KAAK,EAAE,aAAa;IACpB;;OAEG;IACH,aAAa,EAAE,gBAAgB,GAAG,MAAM;IACxC;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC;IAE9B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM;IACb;;OAEG;IACH,aAAa,EAAE,gBAAgB,GAAG,MAAM;IACxC;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC;IAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,QAAQ,CAAC,QAAQ,CAAC,MAAM,SAAS,WAAW;IAC1C;;OAEG;IACH,QAAQ,EAAE,MAAM,EAAE;IAClB;;OAEG;IACH,MAAM,EAAE,MAAM;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CACf,cAAc,CAAC,MAAM,CAAC,EACtB;QACE,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CACF;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,WAAW,CAAC,MAAM,SAAS,WAAW;IAC7C;;OAEG;IACH,QAAQ,EAAE,MAAM,EAAE;IAClB;;OAEG;IACH,MAAM,EAAE,MAAM;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAEzC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,YAAY;IACnB;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IAEF;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAAC;QAC7D,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF;;OAEG;IAGH;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,KAAK;IACZ;;;;OAIG;IACH,QAAQ,CAAC,EAAE;QACT;;;;;;;;WAQG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;QACf;;;;;;;;;;WAUG;QACH,KAAK,CAAC,EAAE,EAAE,CAAC;KACZ;IACD;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAEhB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM;IACb;;OAEG;IACH,OAAO,EAAE,eAAe;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAEhB;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,QAAQ,CAAC"}

package/dist/types/src/2-types.d.ts

@@ -0,0 +1,270 @@
+import type { JTDDataType } from "ajv/dist/core";
+import type { Operation as JSONPatchOperation } from "fast-json-patch";
+/**
+ * Objects are the atomic unit in Graffiti that can represent both data (*e.g.* a social media post or profile)
+ * and activities (*e.g.* a like or follow).
+ * Objects are created and modified by a single {@link actor | `actor`}.
+ *
+ * Most of an object's content is stored in its {@link value | `value`} property, which can be any JSON
+ * object. However, we recommend using properties from the
+ * [Activity Vocabulary](https://www.w3.org/TR/activitystreams-vocabulary/)
+ * or properties that emerge in the Graffiti [folksonomy](https://en.wikipedia.org/wiki/Folksonomy)
+ * to promote interoperability.
+ *
+ * The {@link name | `name`}, {@link actor | `actor`}, and {@link source | `source`}
+ * properties together uniquely describe the {@link GraffitiLocation | object's location}
+ * and can be {@link Graffiti.locationToUri | converted to a globally unique URI}.
+ *
+ * The {@link channels | `channels`} and {@link allowed | `allowed`} properties
+ * enable the object's creator to shape the visibility of and access to their object.
+ *
+ * The {@link tombstone | `tombstone`} and {@link lastModified | `lastModified`} properties are for
+ * caching and synchronization.
+ */
+export interface GraffitiObjectBase {
+    /**
+     * The object's content as freeform JSON. We recommend using properties from the
+     * [Activity Vocabulary](https://www.w3.org/TR/activitystreams-vocabulary/)
+     * or properties that emerge in the Graffiti [folksonomy](https://en.wikipedia.org/wiki/Folksonomy)
+     * to promote interoperability.
+     */
+    value: {};
+    /**
+     * An array of URIs the creator associates with the object. Objects can only be found by querying
+     * one of the object's channels using the
+     * {@link Graffiti.discover} method. This allows creators to express the intended audience of their object
+     * which helps to prevent [context collapse](https://en.wikipedia.org/wiki/Context_collapse) even
+     * in the highly interoperable ecosystem that Graffiti envisions. For example, channel URIs may be:
+     * - A user's own {@link actor | `actor`} URI. Putting an object in this channel is a way to broadcast
+     * the object to the user's followers, like posting a tweet.
+     * - The URI of a Graffiti post. Putting an object in this channel is a way to broadcast to anyone viewing
+     * the post, like commenting on a tweet.
+     * - A URI representing a topic. Putting an object in this channel is a way to broadcast to anyone interested
+     * in that topic, like posting in a subreddit.
+     */
+    channels: string[];
+    /**
+     * An optional array of {@link actor | `actor`} URIs that the creator allows to access the object.
+     * If no `allowed` array is provided, the object can be accessed by anyone (so long as they
+     * also know the right {@link channels | `channel` } to look in). An object can always be accessed by its creator, even if
+     * the `allowed` array is empty.
+     *
+     * The `allowed` array is not revealed to users other than the creator, like
+     * a BCC email. A user may choose to add a `to` property to the object's {@link value | `value`} to indicate
+     * other recipients, however this is not enforced by Graffiti and may not accurately reflect the actual `allowed` array.
+     *
+     * `allowed` can be combined with {@link channels | `channels`}. For example, to send someone a direct message
+     * the sender should put their object in the channel of the recipient's {@link actor | `actor`} URI to notify them of the message and also add
+     * the recipient's {@link actor | `actor`} URI to the `allowed` array to prevent others from seeing the message.
+     */
+    allowed?: string[];
+    /**
+     * The URI of the `actor` that {@link Graffiti.put | created } the object. This `actor` also has the unique permission to
+     * {@link Graffiti.patch | modify} or {@link Graffiti.delete | delete} the object.
+     *
+     * We borrow the term actor from the ActivityPub because
+     * [like in ActivityPub](https://www.w3.org/TR/activitypub/#h-note-0)
+     * there is not necessarily a one-to-one mapping between actors and people/users.
+     * Multiple people can share the same actor or one person can have multiple actors.
+     * Actors can also be bots.
+     *
+     * In Graffiti, actors are always globally unique URIs which
+     * allows them to also function as {@link channels | `channels`}.
+     */
+    actor: string;
+    /**
+     * A name for the object. This name is not globally unique but it is unique when
+     * combined with the {@link actor | `actor`} and {@link source | `source`}.
+     * Often times it is not specified by the user and randomly generated during {@link Graffiti.put | creation}.
+     * If an object is created with the same `name`, `actor`, and `source` as an existing object,
+     * the existing object will be replaced with the new object.
+     */
+    name: string;
+    /**
+     * The URI of the source that stores the object. In some decentralized implementations,
+     * it can represent the server or [pod](https://en.wikipedia.org/wiki/Solid_(web_decentralization_project)#Design)
+     * that a user has delegated to store their objects. In others it may represent the distributed
+     * storage network that the object is stored on.
+     */
+    source: string;
+    /**
+     * The time the object was last modified, measured in milliseconds since January 1, 1970.
+     * This is used for caching and synchronization.
+     * A number, rather than an ISO string or Date object, is used for easy comparison, sorting,
+     * and JSON Schema [range queries](https://json-schema.org/understanding-json-schema/reference/numeric#range).
+     *
+     * It is possible to use this value to sort objects in a user's interface but in many cases it would be better to
+     * use a `createdAt` property in the object's {@link value | `value`} to indicate when the object was created
+     * rather than when it was modified.
+     */
+    lastModified: number;
+    /**
+     * A boolean indicating whether the object has been deleted.
+     * Depending on implementation, objects stay available for some time after deletion to allow for synchronization.
+     */
+    tombstone: boolean;
+}
+/**
+ * This type constrains the {@link GraffitiObjectBase} type to adhere to a
+ * particular [JSON schema](https://json-schema.org/).
+ * This allows for static type-checking of an object's {@link GraffitiObjectBase.value | `value`}
+ * which is otherwise a freeform JSON object.
+ *
+ * Schema-aware objects are returned by {@link Graffiti.get} and {@link Graffiti.discover}.
+ */
+export type GraffitiObject<Schema> = GraffitiObjectBase & JTDDataType<Schema>;
+/**
+ * This is a subset of properties from {@link GraffitiObjectBase} that uniquely
+ * identify an object's location: {@link GraffitiObjectBase.actor | `actor`},
+ * {@link GraffitiObjectBase.name | `name`}, and {@link GraffitiObjectBase.source | `source`}.
+ * Attempts to create an object with the same `actor`, `name`, and `source`
+ * as an existing object will replace the existing object (see {@link Graffiti.put}).
+ *
+ * This location can be converted to
+ * a globally unique URI using {@link Graffiti.locationToUri}.
+ */
+export type GraffitiLocation = Pick<GraffitiObjectBase, "actor" | "name" | "source">;
+/**
+ * This object is a subset of {@link GraffitiObjectBase} that a user must construct locally before calling {@link Graffiti.put}.
+ * This local copy does not require system-generated properties and may be statically typed with
+ * a [JSON schema](https://json-schema.org/) to prevent the accidental creation of erroneous objects.
+ *
+ * This local object must have a {@link GraffitiObjectBase.value | `value`} and {@link GraffitiObjectBase.channels | `channels`}
+ * and may optionally have an {@link GraffitiObjectBase.allowed | `allowed`} property.
+ *
+ * It may also contain any of the {@link GraffitiLocation } properties: {@link GraffitiObjectBase.actor | `actor`},
+ * {@link GraffitiObjectBase.name | `name`}, and {@link GraffitiObjectBase.source | `source`}.
+ * If the location provided exactly matches an existing object, the existing object will be replaced.
+ * If no `name` is provided, one will be randomly generated.
+ * If no `actor` is provided, the `actor` from the supplied {@link GraffitiSession | `session` } will be used.
+ * If no `source` is provided, one may be inferred by the depending on implementation.
+ *
+ * This object does not need a {@link GraffitiObjectBase.lastModified | `lastModified`} or {@link GraffitiObjectBase.tombstone | `tombstone`}
+ * property since these are automatically generated by the Graffiti system.
+ */
+export type GraffitiPutObject<Schema> = Pick<GraffitiObjectBase, "value" | "channels" | "allowed"> & Partial<GraffitiLocation> & JTDDataType<Schema>;
+/**
+ * This object contains information that
+ * {@link GraffitiObjectBase.source | `source`}s can
+ * use to verify that a user has permission to operate a
+ * particular {@link GraffitiObjectBase.actor | `actor`}.
+ * This object is required of all {@link Graffiti} methods
+ * that modify objects and is optional for methods that read objects.
+ *
+ * At a minimum the `session` object must contain the
+ * {@link GraffitiSession.actor | `actor`} URI the user wants to authenticate with.
+ * However it is likely that the `session` object must contain other
+ * implementation-specific properties.
+ * For example, a Solid implementation might include a
+ * [`fetch`](https://docs.inrupt.com/developer-tools/api/javascript/solid-client-authn-browser/functions.html#fetch)
+ * function. A distributed implementation may include
+ * a cryptographic signature.
+ *
+ * As to why the `session` object is passed as an argument to every method
+ * rather than being an internal property of the {@link Graffiti} instance,
+ * this is primarily for type-checking to catch bugs related to login state.
+ * Graffiti applications can expose some functionality to users who are not logged in
+ * with {@link Graffiti.get} and {@link Graffiti.discover} but without type-checking
+ * the `session` it can be easy to forget to hide buttons that trigger
+ * other methods that require login.
+ * In the future, `session` object may be updated to include scope information
+ * and passing the `session` to each method can type-check whether the session provides the
+ * necessary permissions.
+ *
+ * Passing the `session` object per-method also allows for multiple sessions
+ * to be used within the same application, like an Email client fetching from
+ * multiple accounts.
+ */
+export interface GraffitiSession {
+    /**
+     * The {@link GraffitiObjectBase.actor | `actor`} a user wants to authenticate with.
+     */
+    actor: string;
+    /**
+     * A yet undefined property detailing what operations the session
+     * grants the user to perform. For example, to allow a user to
+     * read private messages from a particular set of channels or
+     * to allow the user to write object matching a particular schema.
+     */
+    scope?: {};
+}
+/**
+ * This is the format for patches that modify {@link GraffitiObjectBase} objects
+ * using the {@link Graffiti.patch} method. The patches must
+ * be an array of [JSON Patch](https://jsonpatch.com) operations.
+ * Patches can only be applied to the
+ * {@link GraffitiObjectBase.value | `value`}, {@link GraffitiObjectBase.channels | `channels`},
+ * and {@link GraffitiObjectBase.allowed | `allowed`} properties since the other
+ * properties either describe the object's location or are automatically generated.
+ * (See also {@link GraffitiPutObject}).
+ */
+export interface GraffitiPatch {
+    /**
+     * An array of [JSON Patch](https://jsonpatch.com) operations to
+     * modify the object's {@link GraffitiObjectBase.value | `value`}. The resulting
+     * `value` must still be a JSON object.
+     */
+    value?: JSONPatchOperation[];
+    /**
+     * An array of [JSON Patch](https://jsonpatch.com) operations to
+     * modify the object's {@link GraffitiObjectBase.channels | `channels`}. The resulting
+     * `channels` must still be an array of strings.
+     */
+    channels?: JSONPatchOperation[];
+    /**
+     * An array of [JSON Patch](https://jsonpatch.com) operations to
+     * modify the object's {@link GraffitiObjectBase.allowed | `allowed`} property. The resulting
+     * `allowed` property must still be an array of strings or `undefined`.
+     */
+    allowed?: JSONPatchOperation[];
+}
+/**
+ * This type represents a stream of data that are
+ * returned by Graffiti's query-like operations such as
+ * {@link Graffiti.discover} and {@link Graffiti.listChannels}.
+ *
+ * Errors are returned within the stream rather than as
+ * exceptions that would halt the entire stream. This is because
+ * some implementations may pull data from multiple
+ * {@link GraffitiObjectBase.source | `source`}s
+ * including some that may be unreliable. In many cases,
+ * these errors can be safely ignored.
+ *
+ * The stream is an [`AsyncGenerator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
+ * that can be iterated over using `for await` loops or calling `next` on the generator.
+ * The stream can be terminated by breaking out of a loop calling `return` on the generator.
+ */
+export type GraffitiStream<TValue, TReturn = void> = AsyncGenerator<{
+    error?: undefined;
+    value: TValue;
+} | {
+    error: Error;
+    source: string;
+}, TReturn>;
+/**
+ * The event type produced in {@link Graffiti.sessionEvents}
+ * when a user logs in manually from {@link Graffiti.login}
+ * or when their session is restored from a previous login.
+ * The event name to listen for is `login`.
+ */
+export type GraffitiLoginEvent = CustomEvent<{
+    state?: string;
+} & ({
+    error: Error;
+    session?: undefined;
+} | {
+    error?: undefined;
+    session: GraffitiSession;
+})>;
+/**
+ * The event type produced in {@link Graffiti.sessionEvents}
+ * when a user logs out either manually with {@link Graffiti.logout}
+ * or when their session times out or otherwise becomes invalid.
+ * The event name to listen for is `logout`.
+ */
+export type GraffitiLogoutEvent = CustomEvent<{
+    actor: string;
+    state?: string;
+    error?: Error;
+}>;
+//# sourceMappingURL=2-types.d.ts.map

package/dist/types/src/2-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"2-types.d.ts","sourceRoot":"","sources":["../../../src/2-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,IAAI,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,KAAK,EAAE,EAAE,CAAC;IAEV;;;;;;;;;;;;OAYG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;;;;;;;;OAYG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;;;;;OASG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,IAAI,kBAAkB,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE9E;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,kBAAkB,EAClB,OAAO,GAAG,MAAM,GAAG,QAAQ,CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,iBAAiB,CAAC,MAAM,IAAI,IAAI,CAC1C,kBAAkB,EAClB,OAAO,GAAG,UAAU,GAAG,SAAS,CACjC,GACC,OAAO,CAAC,gBAAgB,CAAC,GACzB,WAAW,CAAC,MAAM,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,CAAC;CACZ;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAEhC;;;;OAIG;IACH,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAC/D;IACE,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,GACD;IACE,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,EACH,OAAO,CACR,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAC1C;IACE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,CACA;IACE,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB,GACD;IACE,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,eAAe,CAAC;CAC1B,CACJ,CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC,CAAC"}

package/dist/types/src/3-errors.d.ts

@@ -0,0 +1,25 @@
+export declare class GraffitiErrorUnauthorized extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorForbidden extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorNotFound extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorInvalidSchema extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorSchemaMismatch extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorPatchTestFailed extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorPatchError extends Error {
+    constructor(message?: string);
+}
+export declare class GraffitiErrorInvalidUri extends Error {
+    constructor(message?: string);
+}
+//# sourceMappingURL=3-errors.d.ts.map

package/dist/types/src/3-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"3-errors.d.ts","sourceRoot":"","sources":["../../../src/3-errors.ts"],"names":[],"mappings":"AAAA,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,CAAC,EAAE,MAAM;CAK7B"}

package/dist/types/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./1-api";
+export * from "./2-types";
+export * from "./3-errors";
+export type { JSONSchema4 } from "json-schema";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/types/tests/crud.d.ts

@@ -0,0 +1,3 @@
+import { type GraffitiFactory, type GraffitiSession } from "../src/index";
+export declare const graffitiCRUDTests: (useGraffiti: GraffitiFactory, useSession1: () => GraffitiSession, useSession2: () => GraffitiSession) => void;
+//# sourceMappingURL=crud.d.ts.map

package/dist/types/tests/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../tests/crud.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,eAAe,EAQrB,MAAM,cAAc,CAAC;AAGtB,eAAO,MAAM,iBAAiB,gBACf,eAAe,eACf,MAAM,eAAe,eACrB,MAAM,eAAe,SAucnC,CAAC"}

package/dist/types/tests/discover.d.ts

@@ -0,0 +1,3 @@
+import { type GraffitiFactory, type GraffitiSession } from "../src/index";
+export declare const graffitiDiscoverTests: (useGraffiti: GraffitiFactory, useSession1: () => GraffitiSession, useSession2: () => GraffitiSession) => void;
+//# sourceMappingURL=discover.d.ts.map

package/dist/types/tests/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../../tests/discover.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,eAAe,EAGrB,MAAM,cAAc,CAAC;AAGtB,eAAO,MAAM,qBAAqB,gBACnB,eAAe,eACf,MAAM,eAAe,eACrB,MAAM,eAAe,SA0kBnC,CAAC"}

package/dist/types/tests/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./location";
+export * from "./crud";
+export * from "./synchronize";
+export * from "./discover";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/tests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tests/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/types/tests/location.d.ts

@@ -0,0 +1,3 @@
+import { type GraffitiFactory } from "../src/index";
+export declare const graffitiLocationTests: (useGraffiti: GraffitiFactory) => void;
+//# sourceMappingURL=location.d.ts.map

package/dist/types/tests/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../tests/location.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAG7E,eAAO,MAAM,qBAAqB,gBAAiB,eAAe,SAkCjE,CAAC"}

package/dist/types/tests/synchronize.d.ts

@@ -0,0 +1,3 @@
+import { type GraffitiFactory, type GraffitiSession } from "../src/index";
+export declare const graffitiSynchronizeTests: (useGraffiti: GraffitiFactory, useSession1: () => GraffitiSession, useSession2: () => GraffitiSession) => void;
+//# sourceMappingURL=synchronize.d.ts.map

package/dist/types/tests/synchronize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronize.d.ts","sourceRoot":"","sources":["../../../tests/synchronize.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAG1E,eAAO,MAAM,wBAAwB,gBACtB,eAAe,eACf,MAAM,eAAe,eACrB,MAAM,eAAe,SA2PnC,CAAC"}

package/dist/types/tests/utils.d.ts

@@ -0,0 +1,8 @@
+import type { GraffitiPutObject, GraffitiStream } from "../src";
+export declare function randomString(): string;
+export declare function randomValue(): {
+    [x: string]: string;
+};
+export declare function randomPutObject(): GraffitiPutObject<{}>;
+export declare function nextStreamValue<S, T>(iterator: GraffitiStream<S, T>): Promise<S>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/tests/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../tests/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEhE,wBAAgB,YAAY,IAAI,MAAM,CAMrC;AAED,wBAAgB,WAAW;;EAI1B;AAED,wBAAgB,eAAe,IAAI,iBAAiB,CAAC,EAAE,CAAC,CAKvD;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,cAIzE"}

package/package.json

@@ -1,23 +1,33 @@
 {
   "name": "@graffiti-garden/api",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The heart of Graffiti",
-  "types": "src/index.ts",
-  "module": "dist/index.js",
-  "main": "dist/index.cjs.js",
+  "types": "./dist/types/src/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/index.cjs.js",
   "exports": {
     ".": {
       "import": {
-        "types": "./src/index.ts",
+        "types": "./dist/types/src/index.d.ts",
         "node": "./dist/index.cjs.js",
         "default": "./dist/index.js"
       },
       "require": {
-        "types": "./src/index.ts",
+        "types": "./dist/types/src/index.d.ts",
         "default": "./dist/index.cjs.js"
       }
     },
-    "./tests": "./tests/index.ts"
+    "./tests": {
+      "import": {
+        "types": "./dist/types/tests/index.d.ts",
+        "node": "./dist/tests/index.cjs.js",
+        "default": "./dist/tests/index.js"
+      },
+      "require": {
+        "types": "./dist/types/tests/index.d.ts",
+        "default": "./dist/tests/index.cjs.js"
+      }
+    }
   },
   "files": [
     "src",