Changeset 709dc6f in Klonkt

Timestamp:

08/09/2026 04:59:31 PM (4 weeks ago)

Author:

Bart <bart@…>

Branches:

main

Children:

89d3c06

Parents:

e62eee4

Message:

Twee richtingen, twee poorten: shaer:following naast shaer:follows

In de catalogus stond één rij voor twee mechanismen. Het paneel telde
listReviewsByDirection(slug, 'incoming') en zette dat getal onder
shaer:follows, dus een guardian las "3 wachtend" en wist niet of er drie
vreemden bij zijn kind wilden of dat zijn kind drie keer had gevraagd of het
iemand mocht volgen. Dat zijn niet dezelfde zorg, en sinds shaer-p729 bestaan
ze allebei echt.

Nu twee poorten, en het verschil ertussen is opzet. §5.3 EIST dat een Follow
naar een ward langs de guardians gaat: shaer:follows blijft dus fixed. Over de
andere richting zegt de FEP niets — wat je verder gated is expliciet aan de
implementatie gelaten — dus shaer:following is onze keuze, en dan hoort hij ook
echt losgelaten te kunnen worden. Verstelbaar, met gate_following als kolom en
dezelfde automatiek als de rest: onbeslist is dicht voor een ward en open voor
ieder ander. Een kind dat erin groeit hoeft niet eeuwig te blijven vragen.

Geen eigen ownFollowsAllowed(): wardGateAllowed() is er al en zegt er zelf bij
dat het één implementatie hoort te zijn. Een derde kopie zou precies de tweede
plek zijn die er anders over kan gaan denken.

De labels zijn nog aan de clients: de server geeft de feature-naam door, de
Guardian PWA en Shaer moeten er nog woorden bij kiezen.

Co-Authored-By: Claude Opus 5 <claude@…>

Files:

• src/config/database.js (modified) (1 diff)
• src/services/ActivityPubService.js (modified) (1 diff)
• src/services/guardianship/gated.js (modified) (2 diffs)
• src/services/guardianship/queues.js (modified) (2 diffs)
• test/outgoing-follow-gate.test.js (modified) (1 diff)

src/config/database.js

@@ -177 +177 @@
   ensureColumn('sites', 'gate_custom_emoji', 'INTEGER');  // FEP-9098 emoji-plaatjes (shaer-ytw)
   ensureColumn('sites', 'gate_account_move', 'INTEGER');  // FEP-7628 Move (shaer-tge)
+  // Wie de ward ZELF mag volgen (shaer-p729): de tegenhanger van shaer:follows,
+  // dat over de andere richting gaat. §5.3 schrijft alleen het doorsturen voor
+  // van een Follow NAAR een ward; wat je verder gated is een keuze van de
+  // implementatie, en dit is die keuze. Verstelbaar, anders dan de inkomende
+  // kant: een kind dat ouder wordt hoort niet eeuwig te blijven vragen.
+  ensureColumn('sites', 'gate_following', 'INTEGER');     // zelf iemand volgen (shaer-p729)
   // The heavier sibling (FEP-633c 5.6): may a player from outside this app run
   // INSIDE it? A preview is a picture; playback hands the screen to a third

src/services/ActivityPubService.js

@@ -5476 +5476 @@
   const guardians = Guardianship.listGuardians(slug).map((g) => g.other_uri);
   if (!guardians.length) return null;                                   // not a ward: nothing to gate
+  // shaer:following (shaer-p729) — its own gate, apart from shaer:follows,
+  // which governs the OTHER direction. §5.3 fixes the inbound one on: a Follow
+  // aimed at a ward MUST pass the guardians. About this direction the FEP says
+  // nothing, so it is ours to set and ours to let go of, and the guardians can
+  // relax it for a child who has grown into it. Undecided means gated for a
+  // ward, the same automatiek as the rest of the family.
+  const gateRow = db.prepare('SELECT gate_following FROM sites WHERE slug = ?').get(slug);
+  if (Guardianship.wardGateAllowed(gateRow && gateRow.gate_following, true)) return null;
   if (guardians.includes(targetUri)) return null;                       // your own guardian
   if (Guardianship.outgoing.isMutual(slug, targetUri)) return null;     // already vetted by name

src/services/guardianship/gated.js

@@ -68 +68 @@
   'shaer:customEmoji': 'gate_custom_emoji',
   'shaer:accountMove': 'gate_account_move',
+  'shaer:following': 'gate_following',
 };
 /**
@@ -112 +113 @@
   { feature: 'shaer:customEmoji', kind: 'setting', reversible: true, bead: 'shaer-ytw' },
   { feature: 'shaer:accountMove', kind: 'setting', reversible: true, bead: 'shaer-tge' },
-  // Altijd aan voor een ward (5.3): niet te verzetten, wel te tonen. Een paneel
-  // dat alleen verstelbare dingen laat zien verzwijgt de helft van wat er geldt.
+  // Wie de ward mag VOLGEN, en wie de ward mag volgen: twee poorten, want twee
+  // vragen. Ze stonden hier als één rij, en dan telt het paneel de ene richting
+  // en zwijgt over de andere -- een guardian ziet "follows: 3 wachtend" en weet
+  // niet of er drie vreemden bij zijn kind willen of dat zijn kind drie keer
+  // heeft gevraagd of het iemand mag volgen. Dat zijn niet dezelfde zorg.
+  //
+  // Inkomend is vast: §5.3 EIST dat een Follow naar een ward langs de guardians
+  // gaat, dus die staat aan en blijft aanstaan. Tonen mag, verzetten niet.
   { feature: 'shaer:follows', kind: 'perRequest', reversible: true, fixed: true },
+  // Uitgaand is verstelbaar, en dat verschil is opzet. De FEP zegt over deze
+  // richting niets: §5.3 gaat alleen over een Follow die op een ward AF komt.
+  // Wat je verder gated is expliciet aan de implementatie gelaten, dus dit is
+  // onze keuze en niet die van de spec -- en dan hoort hij ook echt te kunnen
+  // worden losgelaten, want een kind dat ouder wordt hoort niet eeuwig te
+  // blijven vragen wie het mag volgen (shaer-p729, shaer-yeo5).
+  { feature: 'shaer:following', kind: 'perRequest', reversible: true, bead: 'shaer-p729' },
 
   // GEPLAND, en dat is bij deze twee geen achterstand maar een besluit.

src/services/guardianship/queues.js

@@ -158 +158 @@
 export function wardGates(mySlug, wardUri) {
   const statuses = wardGuardianStatuses(wardUri);
-  const wachtend = follows.listReviewsByDirection(mySlug, 'incoming')
+  // Per richting geteld, want het zijn twee zorgen. "follows: 3 wachtend" liet
+  // een guardian niet zien of er drie vreemden bij zijn kind willen of dat zijn
+  // kind drie keer heeft gevraagd of het iemand mag volgen (shaer-p729).
+  const wachtendIn = follows.listReviewsByDirection(mySlug, 'incoming')
+    .filter((r) => r.ward_uri === wardUri).length;
+  const wachtendUit = follows.listReviewsByDirection(mySlug, 'outgoing')
     .filter((r) => r.ward_uri === wardUri).length;
   return gated.gateRows({
@@ -172 +177 @@
       feature: p.feature, value: !!p.value, status: gated.sentStatus(p, Date.now()),
     })),
-    waiting: { 'shaer:follows': wachtend || undefined },
+    waiting: {
+      'shaer:follows': wachtendIn || undefined,
+      'shaer:following': wachtendUit || undefined,
+    },
     // De vraag van het kind zelf staat APART van wat er in een wachtrij staat
     // (shaer-8ru). Allebei "n waiting" noemen maakt van twee verschillende

test/outgoing-follow-gate.test.js

@@ -152 +152 @@
   assert.notEqual(uit && uit.held, true);
 });
+
+// ── shaer:following als eigen poort (shaer-p729) ──────────────────────────
+// De uitgaande kant stond als één rij met de inkomende in het paneel, en dan
+// telt een guardian de ene richting en hoort niets over de andere. Nu twee
+// poorten. Het VERSCHIL tussen die twee is opzet: §5.3 eist dat een Follow
+// NAAR een ward langs de guardians gaat, dus die staat vast aan. Over deze
+// richting zegt de FEP niets, dus die is van ons -- en dan hoort hij ook echt
+// losgelaten te kunnen worden.
+
+test('onbeslist betekent dicht voor een ward, net als bij de andere poorten', async () => {
+  const wim = site('wim');
+  guards('wim', local('mum'));
+  const held = await AP.gateOutgoingFollow(wim, 'https://elders.example/users/nieuw');
+  assert.ok(held, 'niemand heeft er iets over besloten, dus vragen we');
+});
+
+test('de guardians kunnen de poort openzetten, en dan vraagt het kind niets meer', async () => {
+  const zoe = site('zoe');
+  guards('zoe', local('mum'));
+  db.prepare('UPDATE sites SET gate_following = 1 WHERE slug = ?').run('zoe');
+  const zoeSite = db.prepare('SELECT * FROM sites WHERE slug = ?').get('zoe');
+  assert.equal(await AP.gateOutgoingFollow(zoeSite, 'https://elders.example/users/nieuw'), null,
+    'een kind dat erin gegroeid is hoeft niet eeuwig te blijven vragen');
+});
+
+test('en weer dicht is ook een besluit', async () => {
+  const zoeSite = db.prepare('SELECT * FROM sites WHERE slug = ?').get('zoe');
+  db.prepare('UPDATE sites SET gate_following = 0 WHERE slug = ?').run('zoe');
+  const dicht = db.prepare('SELECT * FROM sites WHERE slug = ?').get('zoe');
+  assert.ok(await AP.gateOutgoingFollow(dicht, 'https://elders.example/users/weer'),
+    'terugdraaien kan: de poort is reversible');
+  assert.equal(zoeSite.gate_following, 1, '(en de oude rij was echt open)');
+});
+
+test('de twee richtingen tellen apart in het paneel', async () => {
+  const queues = await import('../src/services/guardianship/queues.js');
+  const rows = queues.wardGates('mum', local('kid'));
+  const namen = rows.map((r) => r.feature);
+  assert.ok(namen.includes('shaer:follows'), 'wie het kind wil volgen');
+  assert.ok(namen.includes('shaer:following'), 'en wie het kind wil volgen -- andersom');
+  const uit = rows.find((r) => r.feature === 'shaer:following');
+  assert.equal(uit.adjustable, true, 'deze mag verzet worden');
+  const inn = rows.find((r) => r.feature === 'shaer:follows');
+  assert.equal(inn.adjustable, false, 'en deze niet: §5.3 laat er geen ruimte voor');
+});