aetherlight: import keys and affordance kinds are read through indexes

Subjects gain a ByImportKey index and the affordance catalog a ByKind index.
held_import_keys and the per-patch kind_names set are deleted: import_key_fault
takes a held predicate, and admit_resolved, resolve_patch and
verify_state_shape's open-time check ask the index (or nothing, at open).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
soul 2026-11-20 13:17:05 +01:00
commit 396bc6a63f
4 changed files with 108 additions and 35 deletions

View file

@ -673,6 +673,16 @@ fn populated_worlds() -> Vec<crate::WorldState> {
WorldKernel::create(creation(title), &auth_principal(owner())).unwrap().0
};
let mut worlds = vec![golden_session().0.state];
// Two subjects holding import keys, so the subjects' `ByImportKey` index has
// points to read and to damage.
let mut keyed = crate::tests::creation("Keyed");
for declaration in &mut keyed.patch.declarations {
if let Declaration::Subject(subject) = declaration {
let record = subject.label.clone();
subject.import_key = Some(crate::ImportKey::new("aetherlight.fixture", record));
}
}
worlds.push(WorldKernel::create(keyed, &auth_principal(owner())).unwrap().0.state);
let mut kernel = created("Civic");
civic_world(&mut kernel);
worlds.push(kernel.state);
@ -1345,6 +1355,28 @@ fn reference_scan_disagreement(state: &crate::WorldState) -> Option<String> {
return Some(format!("dependents of {target:?}"));
}
}
let strange = crate::ImportKey::new("aetherlight.fixture", "held by nobody");
for key in state
.subjects
.values()
.filter_map(|subject| subject.import_key.as_ref())
.chain(std::iter::once(&strange))
{
if state.import_key_held(key) != crate::import_key_held_by_scan(state, key) {
return Some(format!("import key {key:?} held"));
}
}
let unnamed = crate::patch::AffordanceKindName("no such kind".into());
for kind in state
.affordance_catalog
.values()
.map(|entry| &entry.kind)
.chain(std::iter::once(&unnamed))
{
if state.kind_taken(kind) != crate::kind_taken_by_scan(state, kind) {
return Some(format!("affordance kind {kind:?} taken"));
}
}
for place in &places {
if crate::under_place(state, *place) != crate::under_place_by_scan(state, *place) {
return Some(format!("under_place {place:?}"));
@ -1465,6 +1497,8 @@ fn a_corrupted_index_is_detected() {
}
}
let indexed: BTreeSet<&str> = [
"aetherlight.subject.v1",
"aetherlight.affordance.v1",
"aetherlight.entity.v1",
"aetherlight.edge.v1",
"aetherlight.position.v1",

View file

@ -520,10 +520,9 @@ pub(super) fn verify_state_shape(state: &WorldState) -> Result<(), JournalError>
));
}
let mut declared_keys = BTreeSet::new();
let no_held = BTreeSet::new();
for subject in state.subjects.values() {
if let Some(key) = &subject.import_key
&& super::patch::import_key_fault(key, &no_held, &mut declared_keys).is_some()
&& super::patch::import_key_fault(key, |_| false, &mut declared_keys).is_some()
{
return Err(JournalError::Corrupt(
"subject import key is malformed or held by two subjects".into(),

View file

@ -96,10 +96,12 @@ use patch::{
};
#[cfg(test)]
pub(crate) use patch::{
AffordanceKindName, AuthorityGrantRef, AuthorityKindName, AuthorityTargetRef, ComponentOpKind,
AuthorityGrantRef, AuthorityKindName, AuthorityTargetRef, ComponentOpKind,
EffectSlot, OutcomeBand, Precondition, RoleSpec,
};
use patch::{EdgeRecord, EntityRecord, LedgerDelta, ResolvedOp, ResolvedPatch};
use patch::{
AffordanceKindName, EdgeRecord, EntityRecord, LedgerDelta, ResolvedOp, ResolvedPatch,
};
use digest::{LtHash16, Partition};
use docs::{Changed, DocKey, Docs, Tracked};
@ -606,8 +608,32 @@ impl docs::Projection<BTreeMap<OfficeName, Office>> for ByIncumbent {
}
}
/// `ByImportKey`: the subject that holds an import key. Retired subjects keep
/// theirs, so a key is never reissued.
#[derive(Clone, Debug)]
struct ByImportKey;
impl docs::Projection<SubjectState> for ByImportKey {
type Point = ImportKey;
fn points(value: &SubjectState, out: &mut Vec<ImportKey>) {
out.extend(value.import_key.clone());
}
}
/// `ByKind`: the catalog entry that names an affordance kind, so a kind is
/// taken exactly when a point holds an entry.
#[derive(Clone, Debug)]
struct ByKind;
impl docs::Projection<Affordance> for ByKind {
type Point = AffordanceKindName;
fn points(value: &Affordance, out: &mut Vec<AffordanceKindName>) {
out.push(value.kind.clone());
}
}
world_state! {
subjects: Docs<SubjectId, SubjectState> = "aetherlight.subject.v1";
subjects: Docs<SubjectId, SubjectState, ByImportKey> = "aetherlight.subject.v1";
entities: Docs<EntityId, EntityRecord, ChildOf> = "aetherlight.entity.v1";
edges: Docs<EdgeId, EdgeRecord, ByEndpoint> = "aetherlight.edge.v1";
positions: Docs<SubjectId, Position, StandsAt> = "aetherlight.position.v1";
@ -649,7 +675,7 @@ world_state! {
pressures: Docs<SubjectId, BTreeMap<PressureSource, PressureMagnitude>, BySource> = "aetherlight.pressures.v1";
/// What an affordance *is*. World-authored and written by `admit_resolved`
/// alone.
affordance_catalog: Docs<AffordanceId, Affordance> = "aetherlight.affordance.v1";
affordance_catalog: Docs<AffordanceId, Affordance, ByKind> = "aetherlight.affordance.v1";
/// Who may exercise which entry: a row exists if and only if the subject
/// holds at least one verb. A grant carries no payload, so a duplicate
/// grant is unrepresentable rather than checked.
@ -1271,7 +1297,7 @@ fn require_play(caller: &CallerId) -> Result<(), KernelError> {
/// `WorldState` so the genesis lane, which resolves declarations before any
/// `WorldState` exists, can call the same owner instead of hand-copying the
/// literal it would otherwise always evaluate to.
fn is_genesis(revision: u64, subjects: &Docs<SubjectId, SubjectState>) -> bool {
fn is_genesis(revision: u64, subjects: &Docs<SubjectId, SubjectState, ByImportKey>) -> bool {
revision == 0 && subjects.is_empty()
}
@ -1542,11 +1568,11 @@ fn admit_resolved(
// The subjects map's only writer holds the same injectivity the resolver
// checks, decided by the same function.
{
let held = patch::held_import_keys(state.subjects.values());
let mut declared = BTreeSet::new();
for subject in &resolved.subjects {
if let Some(key) = &subject.subject.import_key
&& patch::import_key_fault(key, &held, &mut declared).is_some()
&& patch::import_key_fault(key, |key| state.import_key_held(key), &mut declared)
.is_some()
{
return Err(KernelError::Invariant(
"admitted subject's import key is malformed, held or repeated".into(),
@ -2668,6 +2694,31 @@ fn channel_referents_exist(state: &WorldState, record: &ChannelRecord) -> bool {
.is_none_or(|subject_id| state.subjects.contains_key(&subject_id))
}
impl WorldState {
/// Whether a subject, retired or not, holds this import key. One point read
/// of `ByImportKey`.
fn import_key_held(&self, key: &ImportKey) -> bool {
!self.subjects.indexed(key.clone()..=key.clone()).is_empty()
}
/// Whether a catalog entry already names this affordance kind.
fn kind_taken(&self, kind: &AffordanceKindName) -> bool {
!self.affordance_catalog.indexed(kind.clone()..=kind.clone()).is_empty()
}
}
/// What `import_key_held` and `kind_taken` were before their indexes: every
/// subject, every catalog entry. The index reads must equal them.
#[cfg(test)]
fn import_key_held_by_scan(state: &WorldState, key: &ImportKey) -> bool {
state.subjects.values().any(|subject| subject.import_key.as_ref() == Some(key))
}
#[cfg(test)]
fn kind_taken_by_scan(state: &WorldState, kind: &AffordanceKindName) -> bool {
state.affordance_catalog.values().any(|entry| &entry.kind == kind)
}
/// Whether a subject is retired: the one statement of retirement, read by
/// audience derivation, preconditions and resolvers. Only an actual `Retire`
/// sets `SubjectState.retired`.

View file

@ -958,28 +958,19 @@ pub(super) enum ImportKeyFault {
Duplicate,
}
/// The keys the subjects hold, retired ones included, so a key is never
/// reissued. Derived on demand; no stored index.
pub(super) fn held_import_keys<'a>(
subjects: impl IntoIterator<Item = &'a super::SubjectState>,
) -> BTreeSet<&'a ImportKey> {
subjects
.into_iter()
.filter_map(|subject| subject.import_key.as_ref())
.collect()
}
/// The one decision on a key: malformed, held by a subject already in the
/// world, or already claimed in `declared` (which it joins). Every door that
/// admits or loads subjects calls this, so none can decide otherwise.
/// world (`held` asks the subjects' `ByImportKey` index, retired ones
/// included, so a key is never reissued), or already claimed in `declared`
/// (which it joins). Every door that admits or loads subjects calls this, so
/// none can decide otherwise.
pub(super) fn import_key_fault<'a>(
key: &'a ImportKey,
held: &BTreeSet<&ImportKey>,
held: impl Fn(&ImportKey) -> bool,
declared: &mut BTreeSet<&'a ImportKey>,
) -> Option<ImportKeyFault> {
if !key.is_canonical() {
Some(ImportKeyFault::Malformed)
} else if held.contains(key) {
} else if held(key) {
Some(ImportKeyFault::Held)
} else if !declared.insert(key) {
Some(ImportKeyFault::Duplicate)
@ -2414,7 +2405,7 @@ fn resolve_affordance(
site: Site,
reference: &Ref<AffordanceId>,
index: &BTreeMap<DraftHandle, RefKind>,
catalog: &Docs<AffordanceId, Affordance>,
catalog: &Docs<AffordanceId, Affordance, super::ByKind>,
mismatches: &mut Vec<Mismatch>,
) -> Option<Key<AffordanceId>> {
match reference {
@ -2726,7 +2717,7 @@ fn resolve_subject(
site: Site,
reference: &Ref<SubjectId>,
index: &BTreeMap<DraftHandle, RefKind>,
subjects: &Docs<SubjectId, SubjectState>,
subjects: &Docs<SubjectId, SubjectState, super::ByImportKey>,
mismatches: &mut Vec<Mismatch>,
) -> Option<Key<SubjectId>> {
match reference {
@ -3083,16 +3074,13 @@ pub(super) fn resolve_patch(
let speak = kernel_speak_entry();
check_against_grammar(state, &speak_handle, &speak.kind, &speak.roles, &mut mismatches);
}
let mut kind_names: BTreeSet<AffordanceKindName> = state
.affordance_catalog
.values()
.map(|entry| entry.kind.clone())
.collect();
// The kinds this patch declares; a kind the catalog already names is asked
// of its `ByKind` index.
let mut declared_kinds: BTreeSet<AffordanceKindName> = BTreeSet::new();
if genesis {
kind_names.insert(kernel_speak_entry().kind);
declared_kinds.insert(kernel_speak_entry().kind);
}
let held_keys = held_import_keys(state.subjects.values());
let mut declared_keys: BTreeSet<&ImportKey> = BTreeSet::new();
for (position, declaration) in patch.declarations.iter().enumerate() {
let (handle, label, kind) = match declaration {
@ -3137,7 +3125,7 @@ pub(super) fn resolve_patch(
&& let Some(key) = &subject.import_key
{
let handle = subject.handle.clone();
match import_key_fault(key, &held_keys, &mut declared_keys) {
match import_key_fault(key, |key| state.import_key_held(key), &mut declared_keys) {
Some(ImportKeyFault::Malformed) => {
mismatches.push(Mismatch::MalformedImportKey { handle });
}
@ -3166,7 +3154,8 @@ pub(super) fn resolve_patch(
&affordance.roles,
&mut mismatches,
);
if !kind_names.insert(affordance.kind.clone()) {
let taken = state.kind_taken(&affordance.kind);
if !declared_kinds.insert(affordance.kind.clone()) || taken {
mismatches.push(Mismatch::DuplicateAffordanceKind {
handle: affordance.handle.clone(),
});