the commons

the commons: lexicons & spaces

Every record and space on this branch, wired together. Tap a node to trace where it goes on the map (the map stays put so you can see it) and the matching entry opens in the list below. Hit view ↓ when you want to read it.

A space type is a lexicon with "type": "space", paired with a policy (read / write / manage predicate trees over signed claims). Roles ladder as member 10 · builder 20 · facilitator 30 · steward 40.

coop.lexicon.space.beaconkey: any
space
coop.lexicon.space.beacon

One lit beacon's audience.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.beacon",
  "defs": {
    "main": {
      "type": "space",
      "key": "any",
      "name": "Beacon space",
      "description": "One lit beacon's audience. skey = the beacon's rkey; authority = the lighter. Everything the lighter wrote for this beacon lives here (the anchor event or listing, its config, the beacon marker, one share per admitted person) plus the joins (rsvps) and each responder's note (rsvpNote). Read-side rule every projector applies: only the AUTHORITY's beacon/event/listing/config records count — a foreign one admitted by the write policy is ignored; only rsvp, rsvpNote and share are read from other authors, and an rsvpNote counts only when its author wrote the rsvp at the same rkey in this space and its subject names that rsvp.",
      "collections": [
        "coop.lexicon.beacon",
        "coop.lexicon.share",
        "community.lexicon.calendar.rsvp",
        "community.lexicon.calendar.event",
        "coop.lexicon.event.listing",
        "coop.lexicon.event.config",
        "coop.lexicon.rsvpNote"
      ]
    }
  }
}
policy
coop.lexicon.space.beacon.policy
access · predicates over claims
read
any of
the space authority onlya DID explicitly shared with
write
any of
the space authority onlya DID explicitly shared with
managethe space authority only
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.beacon.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.beacon: the lighter (authority) and everyone the lighter authored a `share` for read AND write (a join is an rsvp by an admitted reader); only the lighter manages. Same write=read shape as space.event.invite; the one-lighter read-side filter in the space description is what keeps foreign anchors out of derived state.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#any",
          "of": [
            {
              "$type": "coop.lexicon.policy#authorityOnly"
            },
            {
              "$type": "coop.lexicon.policy#sharedWith",
              "of": "this"
            }
          ]
        },
        "write": {
          "$type": "coop.lexicon.policy#any",
          "of": [
            {
              "$type": "coop.lexicon.policy#authorityOnly"
            },
            {
              "$type": "coop.lexicon.policy#sharedWith",
              "of": "this"
            }
          ]
        },
        "manage": {
          "$type": "coop.lexicon.policy#authorityOnly"
        }
      }
    }
  }
}
coop.lexicon.space.contactkey: literal:self
space
coop.lexicon.space.contact

A person's contact space.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.contact",
  "defs": {
    "main": {
      "type": "space",
      "description": "A person's contact space. Readers = the owner's connections. Placing a channel here IS the introduction-disclosure consent.",
      "key": "literal:self",
      "name": "Contact space",
      "collections": [
        "coop.lexicon.contactChannel",
        "coop.lexicon.channelVerification"
      ]
    }
  }
}
policy
coop.lexicon.space.contact.policy
access · predicates over claims
reada connection of the authority
writethe space authority only
managethe space authority only
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.contact.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.contact: the owner's connections read; only the owner writes/manages.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#connectionOf",
          "of": "authority"
        },
        "write": {
          "$type": "coop.lexicon.policy#authorityOnly"
        },
        "manage": {
          "$type": "coop.lexicon.policy#authorityOnly"
        }
      }
    }
  }
}
coop.lexicon.space.event.detailkey: any
space
coop.lexicon.space.event.detail

An event's private-detail space: confirmed attendees read the exact location / attendee details.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.event.detail",
  "defs": {
    "main": {
      "type": "space",
      "description": "An event's private-detail space: confirmed attendees read the exact location / attendee details. Same skey as the event's invite space — one subject, two audiences, two spaces.",
      "key": "any",
      "name": "Event detail space",
      "collections": [
        "coop.lexicon.event.detail"
      ]
    }
  }
}
policy
coop.lexicon.space.event.detail.policy
access · predicates over claims
read
any of
confirmed for the eventthe space authority onlybuilder+ of the space's authority
writethe space authority only
managethe space authority only
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.event.detail.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.event.detail: confirmed attendees read, AND whoever can HOST the event reads the detail they wrote — the solo person-host (authorityOnly: viewer DID = authority DID) and a hosting scene's Builder+ (memberRole of authority atLeast 20, matching the owner_or_builder event-authoring/host gate: a Builder creates the event and writes its gated detail, so must be able to read it back). Only the authority writes/manages. (U2: the published policy IS the enforced behaviour — a host could not read their own gated detail.)",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#any",
          "of": [
            {
              "$type": "coop.lexicon.policy#confirmedFor",
              "event": "this"
            },
            {
              "$type": "coop.lexicon.policy#authorityOnly"
            },
            {
              "$type": "coop.lexicon.policy#memberRole",
              "of": "authority",
              "atLeast": 20
            }
          ]
        },
        "write": {
          "$type": "coop.lexicon.policy#authorityOnly"
        },
        "manage": {
          "$type": "coop.lexicon.policy#authorityOnly"
        }
      }
    }
  }
}
coop.lexicon.space.event.invitekey: any
space
coop.lexicon.space.event.invite

An event's invite space: the invited (plus the hosting scene's members) read and author their intents here.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.event.invite",
  "defs": {
    "main": {
      "type": "space",
      "description": "An event's invite space: the invited (plus the hosting scene's members) read and author their intents here. skey = the event.",
      "key": "any",
      "name": "Event invite space",
      "collections": [
        "coop.lexicon.invite",
        "community.lexicon.calendar.rsvp",
        "coop.lexicon.approval",
        "coop.lexicon.presence",
        "coop.lexicon.evaluation",
        "community.lexicon.calendar.event",
        "coop.lexicon.event.listing",
        "coop.lexicon.event.config",
        "coop.lexicon.share"
      ]
    }
  }
}
policy
coop.lexicon.space.event.invite.policy
access · predicates over claims
read
any of
invited to the eventa DID explicitly shared withmember+ of the space's authority (+ one hop via member scenes)
write
any of
invited to the eventa DID explicitly shared withmember+ of the space's authority (+ one hop via member scenes)
managebuilder+ of the space's authority
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.event.invite.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.event.invite: invitees (including, via includeMembers, the members of an INVITED scene — they can see and author their RSVPs; a scene invite never opens the detail space), link-holders (a share claim — bearer access, no status), or hosting-scene members read AND write; hosting-scene Builders (memberRole of authority atLeast 20, matching the owner_or_builder host gate) manage.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#any",
          "of": [
            {
              "$type": "coop.lexicon.policy#invited",
              "event": "this",
              "includeMembers": true
            },
            {
              "$type": "coop.lexicon.policy#sharedWith",
              "of": "this"
            },
            {
              "$type": "coop.lexicon.policy#memberRole",
              "of": "authority",
              "atLeast": 10,
              "includeMemberScenes": true
            }
          ]
        },
        "write": {
          "$type": "coop.lexicon.policy#any",
          "of": [
            {
              "$type": "coop.lexicon.policy#invited",
              "event": "this",
              "includeMembers": true
            },
            {
              "$type": "coop.lexicon.policy#sharedWith",
              "of": "this"
            },
            {
              "$type": "coop.lexicon.policy#memberRole",
              "of": "authority",
              "atLeast": 10,
              "includeMemberScenes": true
            }
          ]
        },
        "manage": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "authority",
          "atLeast": 20
        }
      }
    }
  }
}
coop.lexicon.space.introkey: any
space
coop.lexicon.space.intro

A brokered-introduction space.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.intro",
  "defs": {
    "main": {
      "type": "space",
      "description": "A brokered-introduction space. The connector authors the introProposal here and a `share` per party so exactly the two parties (plus the connector authority) can read it. A party mirrors it for the intro OUTCOME: their own space.intro instance holding an evaluation + a share to the connector. skey = the proposal/outcome instance.",
      "key": "any",
      "name": "Introduction space",
      "collections": [
        "coop.lexicon.introProposal",
        "coop.lexicon.share",
        "coop.lexicon.evaluation"
      ]
    }
  }
}
policy
coop.lexicon.space.intro.policy
access · predicates over claims
read
any of
the space authority onlya DID explicitly shared with
writethe space authority only
managethe space authority only
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.intro.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.intro: the authority (connector, or the outcome author) reads/writes/manages; the two parties read via a per-party `share` the authority authored. No status is derived from a space.intro membership — the proposal/outcome records are just there for whoever the authority shared them with.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#any",
          "of": [
            {
              "$type": "coop.lexicon.policy#authorityOnly"
            },
            {
              "$type": "coop.lexicon.policy#sharedWith",
              "of": "this"
            }
          ]
        },
        "write": {
          "$type": "coop.lexicon.policy#authorityOnly"
        },
        "manage": {
          "$type": "coop.lexicon.policy#authorityOnly"
        }
      }
    }
  }
}
coop.lexicon.space.passagekey: any
space
coop.lexicon.space.passage

A passage's member space: the small cohort tending one passage.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.passage",
  "defs": {
    "main": {
      "type": "space",
      "description": "A passage's member space: the small cohort tending one passage. Membership claims for a passage are PLACED IN the passage space itself (in-space membership — one authority may steward many passages, so the space, not the authority, binds the cohort).",
      "key": "any",
      "name": "Passage space",
      "collections": [
        "coop.lexicon.passage",
        "coop.lexicon.membership",
        "coop.lexicon.evaluation",
        "coop.lexicon.market.ask"
      ]
    }
  }
}
policy
coop.lexicon.space.passage.policy
access · predicates over claims
readmember+ of the space's authority
writemember+ of the space's authority
managefacilitator+ of the space's authority
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.passage.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.passage: passage members (in-space membership claims, bound by `this` — the space instance itself) read AND write — tending/outreach are member acts, and the published policy must equal the enforced one; facilitators manage.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "this",
          "atLeast": 10
        },
        "write": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "this",
          "atLeast": 10
        },
        "manage": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "this",
          "atLeast": 30
        }
      }
    }
  }
}
coop.lexicon.space.personalkey: literal:self
space
coop.lexicon.space.personal

A person's personal space: audience of one (the owner).

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.personal",
  "defs": {
    "main": {
      "type": "space",
      "description": "A person's personal space: audience of one (the owner). The private-to-just-me end of the placement spectrum.",
      "key": "literal:self",
      "name": "Personal space",
      "collections": [
        "coop.lexicon.market.ask",
        "coop.lexicon.contactChannel",
        "coop.lexicon.approval",
        "coop.lexicon.interest",
        "coop.lexicon.reflection",
        "coop.lexicon.contact",
        "coop.lexicon.contactList",
        "coop.lexicon.beaconLists",
        "coop.lexicon.accessRule",
        "coop.lexicon.channelVerification",
        "coop.lexicon.block"
      ]
    }
  }
}
policy
coop.lexicon.space.personal.policy
access · predicates over claims
readthe space authority only
writethe space authority only
managethe space authority only
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.personal.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.personal: owner only, all capabilities.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#authorityOnly"
        },
        "write": {
          "$type": "coop.lexicon.policy#authorityOnly"
        },
        "manage": {
          "$type": "coop.lexicon.policy#authorityOnly"
        }
      }
    }
  }
}
coop.lexicon.space.scene.memberkey: literal:self
space
coop.lexicon.space.scene.member

A scene's member space.

view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.scene.member",
  "defs": {
    "main": {
      "type": "space",
      "description": "A scene's member space. Readers/writers = the scene's members (per the companion policy). Singleton per scene. A Beacon circle (sceneType \"beacon.circle\") also keeps its descriptor here and nowhere public.",
      "key": "literal:self",
      "name": "Collective member space",
      "collections": [
        "coop.lexicon.membership",
        "coop.lexicon.scene",
        "coop.lexicon.circleBeacon"
      ]
    }
  }
}
policy
coop.lexicon.space.scene.member.policy
access · predicates over claims
readmember+ of the space's authority (+ one hop via member scenes)
writebuilder+ of the space's authority
managefacilitator+ of the space's authority
view source
{
  "lexicon": 1,
  "id": "coop.lexicon.space.scene.member.policy",
  "defs": {
    "main": {
      "type": "spacePolicy",
      "description": "Access policy for coop.lexicon.space.scene.member: members read (incl. one hop via member scenes), builders write, facilitators manage.",
      "policy": {
        "read": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "authority",
          "atLeast": 10,
          "includeMemberScenes": true
        },
        "write": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "authority",
          "atLeast": 20
        },
        "manage": {
          "$type": "coop.lexicon.policy#memberRole",
          "of": "authority",
          "atLeast": 30
        }
      }
    }
  }
}
public · firehosepublic home · 23

Records whose declared homes include the public firehose (per the placement manifest), broadcast openly and indexed by any AppView. No access perimeter; portable, re-derivable commons data. Many of these can also be placed in a space when the thing they describe is permissioned (an event's records follow the event).

community.lexicon.calendar.eventcommunity.lexicon.calendar.rsvpcoop.lexicon.approvalcoop.lexicon.channelVerificationcoop.lexicon.connectioncoop.lexicon.contactChannelcoop.lexicon.draft.orgcoop.lexicon.draft.profilecoop.lexicon.draft.questionSetcoop.lexicon.draft.sourceAttributioncoop.lexicon.draft.sourceRefcoop.lexicon.evaluationcoop.lexicon.event.configcoop.lexicon.event.listingcoop.lexicon.feed.recipecoop.lexicon.invitecoop.lexicon.market.askcoop.lexicon.market.offercoop.lexicon.membershipcoop.lexicon.placecoop.lexicon.presencecoop.lexicon.profilecoop.lexicon.scene
coop.lexicon.policyreference

the predicate vocabulary: the 8 leaves every policy composes.

predicateparamsgrants when…
memberRoleof, atLeast, includeMemberScenesV holds a membership claim with role >= atLeast. `of: authority` binds to claims authored by the space's authority (the scene); `of: this` binds to claims PLACED IN this space instance (in-space membership — e.g. a passage cohort). `includeMemberScenes: true` adds exactly ONE hop: a role via a scene V is a member of (bounded: claims naming V + one indexed join; no recursion).
connectionOfofThere is a `connection` claim authored by the bound identity naming V as subject.
confirmedForeventThere is a confirmed `approval` claim naming V for the bound event.
invitedeventThere is an `invite` claim naming V (post-bind DID subject) for the bound event.
sharedWithofThere is a `share` claim naming V for the bound space (the one instance-level access record).
authorityOnly—Only the space's authority. (The authority also IMPLICITLY satisfies write/manage for every space it owns.)
anyofUnion of sub-predicates. EMPTY = deny (no vacuous truth).
allofIntersection of sub-predicates. EMPTY = deny (no vacuous truth).

42 record/object lexicons · 8 space types · 8 policy predicates · 126 methods, generated straight from the lexicon sources, so this page can't drift from the schemas.

Portable by design: every public record here is re-derivable by any AppView; every private one is a real lexicon record awaiting native protocol support. The commons outlives the app.

the commons · Liminal