diff --git a/apps/app/App.js b/apps/app/App.js
index 11c581ab..6668f547 100644
--- a/apps/app/App.js
+++ b/apps/app/App.js
@@ -200,6 +200,8 @@ import { refreshMomentSeen } from './src/momentSeenStore'
import SalvosScreen from './src/screens/Salvos'
import EventosScreen from './src/screens/Eventos'
import VisitasScreen from './src/screens/Visitas'
+import VarandinhaScreen from './src/screens/Varandinha'
+import VarandinhaRuaScreen from './src/screens/VarandinhaRua'
import MomentosScreen from './src/screens/Momentos'
import FeiraScreen from './src/screens/Feira'
import AnuncioScreen from './src/screens/Anuncio'
@@ -256,6 +258,8 @@ const Assunto = memo(AssuntoScreen)
const Recados = memo(RecadosScreen)
const Eventos = memo(EventosScreen)
const Visitas = memo(VisitasScreen)
+const Varandinha = memo(VarandinhaScreen)
+const VarandinhaRua = memo(VarandinhaRuaScreen)
const Mensagens = memo(MensagensScreen)
const Mensagem = memo(MensagemScreen)
const Anuncio = memo(AnuncioScreen)
@@ -2253,6 +2257,11 @@ function Member () {
pushScreen({ screen: 'recados', key: key.toLowerCase(), params: {} })
}, [pushScreen])
const openVisitas = useCallback(() => pushScreen({ screen: 'visitas' }), [pushScreen])
+ const openVarandinha = useCallback((key) => {
+ if (typeof key !== 'string') return
+ pushScreen({ screen: 'varandinha', key: key.toLowerCase(), params: {} })
+ }, [pushScreen])
+ const openVarandinhaRua = useCallback(() => pushScreen({ screen: 'varandinha-rua' }), [pushScreen])
const openEventos = useCallback((key) => {
if (typeof key !== 'string') return
pushScreen({ screen: 'eventos', key: key.toLowerCase(), params: {} })
@@ -2318,11 +2327,13 @@ function Member () {
const helpOpen = useHelpOpen()
const helpOpenRef = useRef(helpOpen)
helpOpenRef.current = helpOpen
- const backGuardRef = useRef(null)
+ // Every registered guard checks at call time that its own screen is on top,
+ // so at most one of them answers a back press.
+ const backGuardsRef = useRef(new Set())
const registerBackGuard = useCallback((fn) => {
- backGuardRef.current = fn
+ backGuardsRef.current.add(fn)
return () => {
- if (backGuardRef.current === fn) backGuardRef.current = null
+ backGuardsRef.current.delete(fn)
}
}, [])
// Help opened inside Ajustes or Denunciar keeps sheetOpen true, so it stays.
@@ -3206,10 +3217,14 @@ function Member () {
})
}, [action, node.online, inviteTick])
useEffect(() => {
+ const guarded = () => {
+ for (const fn of backGuardsRef.current) if (fn() === true) return true
+ return false
+ }
if (Platform.OS === 'android') {
const sub = BackHandler.addEventListener('hardwareBackPress', () => {
if (helpOpenRef.current || sheetOpenRef.current) return false
- if (backGuardRef.current?.() === true) return true
+ if (guarded()) return true
if (nav.depth(stackRef.current) === 0) {
if (tabRef.current !== 'avisos') return false
closeAvisos()
@@ -3224,7 +3239,7 @@ function Member () {
if (Platform.OS !== 'web' || typeof globalThis.addEventListener !== 'function') return
const onKey = (event) => {
if (event.key !== 'Escape' || event.defaultPrevented || helpOpenRef.current || sheetOpenRef.current) return
- if (backGuardRef.current?.() === true) {
+ if (guarded()) {
event.preventDefault()
return
}
@@ -3853,6 +3868,7 @@ function Member () {
handleOpenRecados: node.hosted === true ? openRecados : undefined,
handleOpenEventos: node.hosted === true ? openEventos : undefined,
handleOpenVisitas: node.hosted === true ? openVisitas : undefined,
+ handleOpenVarandinha: node.hosted === true ? openVarandinha : undefined,
handleOpenAgenda: node.hosted === true ? openAgenda : undefined,
handleOpenTop: node.hosted === true ? openTop : undefined,
handleComposeSeen: () => setComposeSignal(null),
@@ -3880,6 +3896,7 @@ function Member () {
onOpenPeople: openPeople,
onOpenTestimonials: openTestimonials,
onOpenRecados: h.handleOpenRecados,
+ onOpenVarandinha: h.handleOpenVarandinha,
onOpenEventos: h.handleOpenEventos,
onOpenListings: h.handleOpenListings
}
@@ -3935,6 +3952,23 @@ function Member () {
)
}
+ if (entry.screen === 'varandinha') {
+ // Queued acts make Android Back and Escape ask first, as the top bar
+ // arrow does; the guard answers only while this entry is on top.
+ const guardRegistrar = entryHandlers.current.for(i + ':varandinha', { handleRegisterBackGuard: (fn) => registerBackGuard(() => stackRef.current.length - 1 === i && stackRef.current[i].screen === 'varandinha' && fn()) }).handleRegisterBackGuard
+ return (
+
+
+
+ )
+ }
+ if (entry.screen === 'varandinha-rua') {
+ return (
+
+
+
+ )
+ }
if (entry.screen === 'melhores-amigos') {
return (
@@ -4051,8 +4085,7 @@ function Member () {
}
if (entry.screen === 'anunciar') {
// Anunciar registers once per mount, so the guard checks the stack at
- // call time. backGuardRef holds one guard and Anunciar is its only
- // registrant: a second one would need Anunciar to register again.
+ // call time and answers only while this entry is on top.
const guardRegistrar = entryHandlers.current.for(i + ':anunciar', { handleRegisterBackGuard: (fn) => registerBackGuard(() => stackRef.current.length - 1 === i && stackRef.current[i].screen === 'anunciar' && fn()) }).handleRegisterBackGuard
return (
@@ -4348,6 +4381,7 @@ function Member () {
onOpenRecados={h.handleOpenRecados}
onOpenEventos={h.handleOpenEventos}
onOpenVisitas={h.handleOpenVisitas}
+ onOpenVarandinha={h.handleOpenVarandinha}
onOpenTop={h.handleOpenTop}
/>
)}
@@ -4487,7 +4521,7 @@ function Member () {
showToast(text)
}}
/>
- setAjustes(null)} onInfo={ajustesInfo} termsInfo={termsInfo} onTermsReset={dropTermsAndSync} scheduledDeletion={scheduledDeletion} onDeletionChanged={refreshAccount} inviteNudge={inviteNudge} onOpenPaginas={!deleteFromAviso && pagesOn({ hosted: node.hosted, accountOrigin: node.accountOrigin }) ? () => pushScreen({ screen: 'paginas' }) : undefined} node={node} member={member} phoneGate={phone.gate} phoneKey={phone.key} phoneChecking={phone.pending} phoneVerified={phone.state === 'verificado' && !phone.error} markVerified={markPhoneVerified} recheckPhone={recheckPhone} termsBeforeCreate={termsBeforeCreate} />
+ setAjustes(null)} onInfo={ajustesInfo} termsInfo={termsInfo} onTermsReset={dropTermsAndSync} scheduledDeletion={scheduledDeletion} onDeletionChanged={refreshAccount} inviteNudge={inviteNudge} onOpenVarandinha={!deleteFromAviso && node.hosted === true && ownKey ? () => openVarandinha(ownKey) : undefined} onOpenPaginas={!deleteFromAviso && pagesOn({ hosted: node.hosted, accountOrigin: node.accountOrigin }) ? () => pushScreen({ screen: 'paginas' }) : undefined} node={node} member={member} phoneGate={phone.gate} phoneKey={phone.key} phoneChecking={phone.pending} phoneVerified={phone.state === 'verificado' && !phone.error} markVerified={markPhoneVerified} recheckPhone={recheckPhone} termsBeforeCreate={termsBeforeCreate} />
{/* Mounted after the splash, so it wins: while the boot cover shows it
follows the splash, which stays cream on native (Splash.js). */}
diff --git a/apps/app/src/garden.js b/apps/app/src/garden.js
index dccf7b96..68edd744 100644
--- a/apps/app/src/garden.js
+++ b/apps/app/src/garden.js
@@ -108,6 +108,7 @@ function emptyBalcony () {
on: false,
pots: new Array(rpc.garden.GARDEN_POTS).fill(null),
helpers: [],
+ received: new Array(rpc.garden.GARDEN_POTS).fill(0),
isPage: false,
stale: false,
loading: false,
@@ -168,12 +169,42 @@ export function assembleBalcony (args) {
helps.push({ author: row.author, seq: row.seq, record, follow })
}
const folded = rpc.garden.foldBalcony({ owner, flag, state, helps, given, now })
- return { on: folded.on, pots: folded.pots, helpers: folded.helpers, isPage: false, stale: folded.stale, loading, incomplete, indexing: idx.indexing, refetch }
+ // Helps counted per pot, as the fold counts them: the helper list keeps
+ // one row per neighbour, but a neighbour's helps of several days each
+ // count.
+ const received = folded.on && state !== null
+ ? rpc.garden.foldHelps({ owner, pots: state.pots, helps, now }).perPot
+ : new Array(rpc.garden.GARDEN_POTS).fill(0)
+ return { on: folded.on, pots: folded.pots, helpers: folded.helpers, received, isPage: false, stale: folded.stale, loading, incomplete, indexing: idx.indexing, refetch }
} catch {
return emptyBalcony()
}
}
+// Whether a balcony read proves its owner is not playing: an off answer
+// counts only when both first blocks and every pointer were read, the index
+// was complete and nothing was dated ahead of the reader.
+export function provenOff (result, forced) {
+ return isObject(result) && result.isPage !== true && result.on === false && result.indexing !== true &&
+ result.incomplete !== true && result.stale !== true && forced !== true
+}
+
+// Varandas da rua: the seeder's street page is a claim, so only keys the
+// viewer's own follow list holds are offered, once each, in the seeder's
+// order. Without a follow set nothing is offered.
+export function streetKeys (items, follows) {
+ if (!Array.isArray(items) || !(follows instanceof Set)) return []
+ const out = []
+ const seen = new Set()
+ for (const it of items) {
+ const key = isObject(it) && typeof it.key === 'string' ? it.key.toLowerCase() : null
+ if (key === null || !HEX64.test(key) || seen.has(key) || !follows.has(key)) continue
+ seen.add(key)
+ out.push(key)
+ }
+ return out
+}
+
export function nextLoadStep (args) {
const { attempt, result } = isObject(args) ? args : {}
if (!isObject(result) || result.refetch !== true) return 'done'
diff --git a/apps/app/src/gardenClock.js b/apps/app/src/gardenClock.js
new file mode 100644
index 00000000..3d85fb78
--- /dev/null
+++ b/apps/app/src/gardenClock.js
@@ -0,0 +1,21 @@
+/* global __DEV__ */
+
+// The reader clock of the Varandinha screens. Growth, the dry check and the
+// 72 h help window are judged on the reader's own clock, so this is
+// Date.now(). The Vitrine answers on its demo clock instead (fixtures.now,
+// plus a second per write), so a Vitrine bundle reads that clock here too:
+// on the real clock every demo plant would read ripe, no demo watering would
+// fall inside the window, and nothing could be watered.
+
+import { vitrineEnabled } from './vitrine/enabled.js'
+
+const VITRINE = vitrineEnabled({ EXPO_PUBLIC_VARANDA_VITRINE: process.env.EXPO_PUBLIC_VARANDA_VITRINE }, typeof __DEV__ !== 'undefined' && __DEV__)
+let offset = 0
+if (typeof __DEV__ !== 'undefined' && __DEV__ && process.env.EXPO_PUBLIC_VARANDA_VITRINE === '1' && VITRINE) {
+ const { fixtures } = require('./vitrine/fixtures')
+ offset = Date.parse(fixtures.now) - Date.now()
+}
+
+export function gardenTime (ms = Date.now()) {
+ return ms + offset
+}
diff --git a/apps/app/src/legal.js b/apps/app/src/legal.js
index 778e06a3..d181b279 100644
--- a/apps/app/src/legal.js
+++ b/apps/app/src/legal.js
@@ -3,9 +3,9 @@
// Sources: docs/design.md (LGPD, moderation, identity), docs/app.md and
// SECURITY.md. Planned flows must not read as features already available.
-export const LEGAL_VERSION = 77
+export const LEGAL_VERSION = 78
export const LEGAL_DATE = '17/11/2026'
-export const REVIEW_NOTE = 'Versão 77, sujeita a revisão jurídica. Não é parecer jurídico.'
+export const REVIEW_NOTE = 'Versão 78, sujeita a revisão jurídica. Não é parecer jurídico.'
export const TERMS = {
title: 'Termos de Uso',
@@ -68,6 +68,7 @@ export const TERMS = {
'Você pode criar uma enquete numa publicação do seu diário, com 2 a 4 opções, e criar tópicos, com ou sem enquete, num grupo público. Votar numa enquete é público: o voto em uma enquete do diário é um registro no seu diário, e o voto numa enquete de um grupo público é um registro no grupo, e em ambos qualquer pessoa que leia o seu diário ou o grupo pode ver em quem ou em qual opção você votou, e a pessoa que criou a enquete pode ver o seu voto. O app avisa disso antes do seu primeiro voto. Retirar o voto grava um novo registro que desfaz o anterior, e os registros anteriores, com as suas datas, continuam públicos; cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. Enquetes e tópicos não têm data de encerramento. Os totais de uma enquete do diário vêm do semeador e podem estar incompletos. Em grupos privados não há tópicos nem enquetes, e não vote se não quiser que todos vejam o seu voto.',
'Você pode publicar um evento no seu diário, com título, início, fim opcional e lugar, e criar um evento num grupo público. Eventos são públicos: a publicação de um evento no seu diário, um evento de um grupo e as respostas de presença, Vou e Talvez, são registros que qualquer pessoa que leia o seu diário ou o grupo pode ver, com quem respondeu e o que respondeu, e a pessoa que criou o evento pode ver a sua resposta. Retirar a resposta grava um novo registro, e os registros anteriores, com as suas datas, continuam públicos. Um evento não pode ser editado: para mudá-lo ou cancelá-lo, apague a publicação ou peça a um administrador que a esconda. Em grupos privados não há eventos. O lembrete de um evento fica só no seu aparelho.',
'Visitas é opcional e começa desligado. Se você ligar, o app mostra os perfis que visitaram o seu e registra as suas visitas aos perfis de quem também está com Visitas ligado: a troca é mútua, você só vê quem visitou enquanto o seu interruptor está ligado e o da outra pessoa estava ligado na visita. A lista de visitantes fica só no seu aparelho, com a precisão de um dia, e é apagada quando você desliga. Desligar para de enviar e de receber visitas, mas não desfaz as que já foram enviadas. Visitas não são mensagens: não acordam ninguém e não geram aviso.',
+ 'A Varandinha é um jogo opcional e começa desligada: cada pessoa cuida dos vasos da própria varanda, planta, rega e colhe, e as plantas crescem no relógio de quem olha. Você só rega a varanda de quem segue, uma vez por dia por varanda. Participar, o que você planta, as datas de plantio, rega e colheita e de quem é a varanda que você regou são registros públicos no seu diário, e a pessoa cuja planta você regou vê o seu nome. O jogo não tem dinheiro, compra, recompensa sorteada, ranking nem prêmio, e nenhuma notificação pede para alguém voltar. O estado de cada varanda é declarado por quem joga e não é conferido por ninguém. Sair da Varandinha marca os seus registros do jogo como apagados e deixa no seu diário um registro público de que o jogo foi desligado; cópias que outras pessoas já buscaram podem continuar. Sair apaga só os seus próprios registros: as regas que vizinhos fizeram na sua varanda ficam no diário deles, e só quem regou pode apagá-las.',
'Essa autorização não alcança o conteúdo cifrado das mensagens diretas e dos grupos privados, exceto o que alguém enviar numa denúncia. Ela termina quando você apaga o conteúdo ou exclui a conta, respeitados os Limites da exclusão e o que a associação precisa guardar para moderação e pedidos legais.'
]
},
@@ -209,7 +210,8 @@ export const PRIVACY = {
'Na versão web hospedada e no app instalado, ser fã de alguém e a lista de melhores amigos são registros públicos no seu diário, visíveis para qualquer pessoa, e valem os mais recentes. Deixar de ser fã grava um novo registro que desfaz o anterior, e os registros anteriores, com as suas datas, continuam públicos no diário; ao publicar uma nova lista de melhores amigos, o app marca como apagadas as listas anteriores, e uma lista vazia limpa a lista. Isso segue os limites da exclusão: cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. O número e a lista de fãs de uma pessoa são montados pelo semeador a partir desses registros públicos, mostrados como o número de seguidores, com o aviso de que podem estar incompletos, e o app confere cada fã no diário dele antes de mostrá-lo. Quando alguém abre um perfil, o app pede ao semeador o número de fãs, a lista de melhores amigos e, para cada amigo, onde está o registro em que ele segue o dono do perfil, e quando alguém abre a lista de fãs de uma pessoa o app pede essa lista ao semeador; como esses pedidos vão pela conexão em que o app já se identificou com a sua conta, o semeador vê qual perfil ou qual lista de fãs foi aberta e pode associar essa leitura à conta de quem abriu. Enquanto o diário de uma pessoa ainda está sendo indexado, o semeador mostra o número de fãs que já conhece, avisa que ele pode estar incompleto e deixa de fora da lista os fãs cujo próprio diário ainda não terminou de ser indexado. O índice fica em memória no semeador e some ao reiniciar.',
'Na versão web hospedada e no app instalado, votar numa enquete é público. Numa enquete de uma publicação, o voto é um registro no seu diário, visível para qualquer pessoa que o leia; numa enquete de um tópico de grupo público, o voto é um registro no grupo, visível para os membros que o leem. Em ambos, mostra em quem ou em qual opção você votou. Retirar o voto grava um novo registro que desfaz o anterior, e os registros anteriores, com as suas datas, continuam públicos, dentro dos limites da exclusão: cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. Os totais de uma enquete de publicação são montados pelo semeador a partir desses registros públicos, mostrados com o aviso de que podem estar incompletos, e o app confere cada votante no diário dele antes de mostrá-lo em Quem votou. Quando alguém abre uma enquete ou a lista de quem votou numa opção, o app pede essas informações ao semeador; como esses pedidos vão pela conexão em que o app já se identificou com a sua conta, o semeador vê qual enquete e qual opção foram abertas e pode associar essa leitura à conta de quem abriu. O índice fica em memória no semeador e some ao reiniciar. Os totais e os votantes de uma enquete de grupo vêm do próprio grupo, sem passar pelo índice.',
'Na versão web hospedada e no app instalado, um evento e as respostas de presença, Vou e Talvez, são públicos. Num evento de uma publicação, o evento e a resposta são registros no diário de quem os publicou, visíveis para qualquer pessoa que o leia; num evento de um grupo público, são registros no grupo, visíveis para os membros que o leem. A resposta mostra quem respondeu e o que respondeu, e retirar a resposta grava um novo registro, e os registros anteriores, com as suas datas, continuam públicos, dentro dos limites da exclusão: cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. Quando alguém abre o perfil de uma pessoa, o app pede ao semeador a lista dos eventos dela; como esse pedido vai pela conexão em que o app já se identificou com a sua conta, o semeador vê qual perfil foi aberto e pode associar essa leitura à conta de quem abriu. Os lembretes de eventos ficam só no aparelho, no armazenamento local do navegador ou num arquivo do app, não são enviados a ninguém e não ficam no seu diário. O arquivo de calendário é gerado no próprio aparelho, na versão web.',
- 'No app instalado e na versão web hospedada, Visitas é opcional e começa desligado. Ligado, o app envia um aviso de visita, no máximo 10 por dia, quando você abre o perfil de alguém que também está com Visitas ligado, e busca os avisos que outras pessoas enviaram a você. É mútuo: você só vê quem visitou enquanto o seu interruptor está ligado e o da outra pessoa estava ligado na visita. Ligar ou desligar Visitas grava um registro público e pequeno no seu diário, só com o estado, ligado ou desligado, e a data, e por isso participar é público: qualquer pessoa que leia o seu diário pode ver que Visitas está ligado. A lista de visitantes fica só no seu aparelho, com a precisão de um dia, guardada por até 30 dias, e é apagada quando você desliga. Os avisos viajam selados por semeadores que não conseguem lê-los, num canal à parte das mensagens diretas, e nunca acordam ninguém nem geram notificação; o semeador vê um envelope cifrado sem nome de diário, como nas mensagens diretas, e a conexão pode revelar o endereço de rede. Um semeador que ainda não tem esse canal não recebe avisos, e o app não os envia por outro caminho.'
+ 'No app instalado e na versão web hospedada, Visitas é opcional e começa desligado. Ligado, o app envia um aviso de visita, no máximo 10 por dia, quando você abre o perfil de alguém que também está com Visitas ligado, e busca os avisos que outras pessoas enviaram a você. É mútuo: você só vê quem visitou enquanto o seu interruptor está ligado e o da outra pessoa estava ligado na visita. Ligar ou desligar Visitas grava um registro público e pequeno no seu diário, só com o estado, ligado ou desligado, e a data, e por isso participar é público: qualquer pessoa que leia o seu diário pode ver que Visitas está ligado. A lista de visitantes fica só no seu aparelho, com a precisão de um dia, guardada por até 30 dias, e é apagada quando você desliga. Os avisos viajam selados por semeadores que não conseguem lê-los, num canal à parte das mensagens diretas, e nunca acordam ninguém nem geram notificação; o semeador vê um envelope cifrado sem nome de diário, como nas mensagens diretas, e a conexão pode revelar o endereço de rede. Um semeador que ainda não tem esse canal não recebe avisos, e o app não os envia por outro caminho.',
+ 'No app instalado e na versão web hospedada, a Varandinha é opcional e começa desligada. Ligar ou desligar grava no seu diário um registro público que diz só ligado ou desligado, e por isso participar é público. O que você planta em cada vaso, as datas de plantio, rega e colheita e cada rega que você faz, com a varanda regada, a data e o vaso, também são registros públicos no seu diário, visíveis para qualquer pessoa que o leia, sem texto livre. A pessoa cuja planta você regou vê o seu nome. O estado do jogo é declarado por cada pessoa e não é conferido: a assinatura do diário prova quem gravou o registro, não que a planta cresceu pelas regras. O semeador monta, a partir desses registros públicos, apontadores para eles (a chave do diário e o número do registro e, numa rega, a varanda regada, a data e o vaso), sem guardar planta nem nome, e fica sabendo qual varanda o seu aparelho abre, como já sabe qual perfil uma conexão lê; o aparelho confere cada registro apontado antes de mostrá-lo. Não há dinheiro, compra, recompensa sorteada, ranking nem prêmio, os registros do jogo não são usados para traçar perfil nem para publicidade, e nenhuma notificação pede para alguém voltar. O app mantém só o estado mais recente da sua varanda: ao gravar um novo, marca o anterior como apagado. A cada nova rega, o app marca como apagadas até sete das suas regas com mais de cerca de três dias; as que sobrarem continuam públicas até as regas seguintes ou até você sair. Sair da Varandinha marca como apagados os seus registros do jogo, inclusive as regas que você deu, e deixa no diário o registro público de desligado; cópias que outras pessoas já buscaram podem continuar. Sair apaga só os seus próprios registros: as regas que vizinhos fizeram na sua varanda ficam no diário deles, e só quem regou pode apagá-las.'
]
},
{
diff --git a/apps/app/src/nav.js b/apps/app/src/nav.js
index 570b753e..2a5acc79 100644
--- a/apps/app/src/nav.js
+++ b/apps/app/src/nav.js
@@ -34,13 +34,15 @@
// ':' and requires params.group (the group's hex64 key).
// 'eventos' (a member's events, keyed by the member's hex64; with params.groups,
// a list of up to 12 group keys, the Agenda of a community keyed by its root).
+// 'varandinha' (one balcony of the pot game) is keyed by the owner's hex64;
+// 'varandinha-rua' (Varandas da rua) takes no key.
// The stack is an immutable (frozen) array, oldest first. Invalid entries are
// refused by returning the stack unchanged (never throws); pushing the
// screen that is already on top is a no-op, whatever its params; past
// MAX_DEPTH the oldest entry is dropped.
export const MAX_DEPTH = 20
-export const SCREENS = Object.freeze(['conversa', 'membro', 'curtidas', 'citacoes', 'grupo', 'comunidade', 'comunidade-info', 'mensagem', 'seguindo', 'seguidores', 'paginas', 'novapagina', 'paginaajustes', 'comunidades', 'pedidos', 'anuncio', 'anunciar', 'editar-anuncio', 'avaliar', 'anuncios', 'depoimentos', 'momentos', 'salvos', 'assunto', 'recados', 'fas', 'melhores-amigos', 'topico', 'eventos', 'visitas'])
+export const SCREENS = Object.freeze(['conversa', 'membro', 'curtidas', 'citacoes', 'grupo', 'comunidade', 'comunidade-info', 'mensagem', 'seguindo', 'seguidores', 'paginas', 'novapagina', 'paginaajustes', 'comunidades', 'pedidos', 'anuncio', 'anunciar', 'editar-anuncio', 'avaliar', 'anuncios', 'depoimentos', 'momentos', 'salvos', 'assunto', 'recados', 'fas', 'melhores-amigos', 'topico', 'eventos', 'visitas', 'varandinha', 'varandinha-rua'])
const HEX32 = /^[0-9a-f]{32}$/
const HEX64 = /^[0-9a-f]{64}$/
@@ -106,7 +108,7 @@ export function validEntry (entry) {
return params.oldPage === undefined || isAuthorKey(params.oldPage)
}
if (entry.screen === 'membro' || entry.screen === 'grupo' || entry.screen === 'comunidade' || entry.screen === 'comunidade-info') return isAuthorKey(entry.key)
- if (entry.screen === 'seguindo' || entry.screen === 'seguidores' || entry.screen === 'paginaajustes' || entry.screen === 'anuncios' || entry.screen === 'momentos' || entry.screen === 'recados' || entry.screen === 'fas') return isAuthorKey(entry.key)
+ if (entry.screen === 'seguindo' || entry.screen === 'seguidores' || entry.screen === 'paginaajustes' || entry.screen === 'anuncios' || entry.screen === 'momentos' || entry.screen === 'recados' || entry.screen === 'fas' || entry.screen === 'varandinha') return isAuthorKey(entry.key)
if (entry.screen === 'depoimentos') {
const params = entry.params
if (!isAuthorKey(entry.key)) return false
@@ -114,7 +116,7 @@ export function validEntry (entry) {
if (typeof params !== 'object' || Array.isArray(params)) return false
return params.section === undefined || params.section === 'sent'
}
- if (entry.screen === 'paginas' || entry.screen === 'novapagina' || entry.screen === 'comunidades' || entry.screen === 'salvos' || entry.screen === 'melhores-amigos' || entry.screen === 'visitas') return entry.key === undefined || entry.key === null || entry.key === ''
+ if (entry.screen === 'paginas' || entry.screen === 'novapagina' || entry.screen === 'comunidades' || entry.screen === 'salvos' || entry.screen === 'melhores-amigos' || entry.screen === 'visitas' || entry.screen === 'varandinha-rua') return entry.key === undefined || entry.key === null || entry.key === ''
if (entry.screen === 'citacoes') return isRef(entry.key)
if (entry.screen === 'assunto') return typeof entry.key === 'string' && TAG.test(entry.key)
if (entry.screen === 'curtidas') {
diff --git a/apps/app/src/screens/Ajustes.js b/apps/app/src/screens/Ajustes.js
index c90a789b..8e3c785e 100644
--- a/apps/app/src/screens/Ajustes.js
+++ b/apps/app/src/screens/Ajustes.js
@@ -195,7 +195,7 @@ function AccountCard ({ ownKey, profile, onPress }) {
)
}
-export default function Ajustes ({ screen, onNavigate, onClose, onInfo, termsInfo = null, onTermsReset, scheduledDeletion = null, onDeletionChanged, onOpenPaginas, inviteNudge = 0, node: nodeProp = null, member: gateMember = null, phoneGate = 'off', phoneKey = null, phoneChecking = false, phoneVerified = false, markVerified, recheckPhone, termsBeforeCreate = null }) {
+export default function Ajustes ({ screen, onNavigate, onClose, onInfo, termsInfo = null, onTermsReset, scheduledDeletion = null, onDeletionChanged, onOpenPaginas, onOpenVarandinha, inviteNudge = 0, node: nodeProp = null, member: gateMember = null, phoneGate = 'off', phoneKey = null, phoneChecking = false, phoneVerified = false, markVerified, recheckPhone, termsBeforeCreate = null }) {
const styles = useStyles(makeStyles)
const { colors, mode, setMode } = useTheme()
const node = useNode()
@@ -280,6 +280,10 @@ export default function Ajustes ({ screen, onNavigate, onClose, onInfo, termsInf
onClose()
onOpenPaginas()
}
+ const openVarandinha = () => {
+ onClose()
+ onOpenVarandinha()
+ }
const pushEligible = node.hosted === true && member !== null
// Avisos no aparelho, from the store the shell's note shares (null: not
// read yet, or this node is not the hosted one for this member any more).
@@ -520,6 +524,7 @@ export default function Ajustes ({ screen, onNavigate, onClose, onInfo, termsInf
{hosted ? onNavigate('recados')} /> : null}
{devicesOffered ? onNavigate('aparelhos')} /> : null}
{visitasOn ? : null}
+ {node.hosted === true && typeof onOpenVarandinha === 'function' ? : null}
onNavigate('termos')} />
{visitasOn
diff --git a/apps/app/src/screens/Diario.js b/apps/app/src/screens/Diario.js
index 6df2c654..454ef802 100644
--- a/apps/app/src/screens/Diario.js
+++ b/apps/app/src/screens/Diario.js
@@ -297,7 +297,7 @@ export default function Diario (props) {
return
}
-function DiarioList ({ active, refresh, onSettings, onReply, onPublish, onOpenThread, onOpenMember, onOpenMention, onOpenEngagers, onOpenQuotes, onQuote, onToast, onReport, ownKey, scrollToTop, onDeletedPost, onAvisos, avisosNew, onOpenPeople, onOpenCommunity, onOpenTestimonials, onMessage, onOpenMomentos, onOpenSalvos, onOpenRecados, onOpenEventos, onOpenVisitas, onTabChange, onOpenTop }) {
+function DiarioList ({ active, refresh, onSettings, onReply, onPublish, onOpenThread, onOpenMember, onOpenMention, onOpenEngagers, onOpenQuotes, onQuote, onToast, onReport, ownKey, scrollToTop, onDeletedPost, onAvisos, avisosNew, onOpenPeople, onOpenCommunity, onOpenTestimonials, onMessage, onOpenMomentos, onOpenSalvos, onOpenRecados, onOpenEventos, onOpenVisitas, onOpenVarandinha, onTabChange, onOpenTop }) {
const styles = useStyles(makeStyles)
const { colors, scheme } = useTheme()
const node = useNode()
@@ -839,6 +839,20 @@ function DiarioList ({ active, refresh, onSettings, onReply, onPublish, onOpenTh
)
: null}
+ {node.hosted === true && ownPublicKey && typeof onOpenVarandinha === 'function'
+ ? (
+ onOpenVarandinha(ownPublicKey)}
+ style={({ pressed }) => [styles.salvos, pressed && styles.salvosPressed]}
+ >
+
+ Varandinha
+
+
+ )
+ : null}
setSegmentedHeight(e.nativeEvent.layout.height)}>
diff --git a/apps/app/src/screens/Membro.js b/apps/app/src/screens/Membro.js
index b116921a..74b29b9a 100644
--- a/apps/app/src/screens/Membro.js
+++ b/apps/app/src/screens/Membro.js
@@ -45,6 +45,9 @@ import * as actingAs from '../actingAs'
import { TEXTS, pagesFollow, pagesFollows, pagesSuccessor } from '../pages'
import { MAX_HOPS, moveOf, pageMoveView, resolveChain, shownUnderCut, successorOf } from '../pageMove'
import { rosterRows } from '../pageRoster'
+import { flagOn } from '../garden.js'
+import { peekBatches } from '../scraps.js'
+import { diaryPeekSlots } from '../engagement'
import { Soft, errorText, useBottomPad, useVisibleNow } from '../ui'
import { FollowPill } from '../ui/FollowPill'
import { OfflineNote } from '../ui/OfflineNote'
@@ -287,7 +290,7 @@ export default function Membro (props) {
return
}
-function MembroList ({ entry, ownKey, onBack, onFollowsChanged, onMessage, onReply, onQuote, onReport, onOpenThread, onOpenMember, onOpenMention, onOpenEngagers, onOpenQuotes, onOpenPageSettings, onOpenPeople, onOpenCommunity, onOpenListings, onOpenTestimonials, onOpenRecados, onOpenEventos, onToast, onTabChange }) {
+function MembroList ({ entry, ownKey, onBack, onFollowsChanged, onMessage, onReply, onQuote, onReport, onOpenThread, onOpenMember, onOpenMention, onOpenEngagers, onOpenQuotes, onOpenPageSettings, onOpenPeople, onOpenCommunity, onOpenListings, onOpenTestimonials, onOpenRecados, onOpenEventos, onOpenVarandinha, onToast, onTabChange }) {
const styles = useStyles(makeStyles)
const { colors } = useTheme()
const node = useNode()
@@ -910,6 +913,23 @@ function MembroList ({ entry, ownKey, onBack, onFollowsChanged, onMessage, onRep
const rich = useProfileExtra({ author, enabled: node.hosted === true && !isPage && !blockedHere, request })
const extraShown = extraView(rich.held, now)
const hostedHere = node.hosted === true && !isPage && !blockedHere
+ // The seeder's pointer may name a flag that is off, so the row waits for one
+ // verified peek of that seq.
+ const gardenSeq = rich.index && Number.isSafeInteger(rich.index.garden) ? rich.index.garden : null
+ const [gardenOn, setGardenOn] = useState(false)
+ useEffect(() => {
+ setGardenOn(false)
+ if (!hostedHere || gardenSeq === null || typeof author !== 'string') return undefined
+ let live = true
+ ;(async () => {
+ for (const params of peekBatches(author, [gardenSeq])) {
+ const peek = await diaryPeekSlots.run(() => (live ? request('diary.peek', params) : null), { front: true })
+ if (!live) return
+ if (peek && peek.key === author && flagOn(peek.entries, gardenSeq)) { setGardenOn(true); return }
+ }
+ })().catch(() => {})
+ return () => { live = false }
+ }, [hostedHere, gardenSeq, author, request])
const topRead = useTopFriends({ owner: author, ownKey, index: rich.index, request, enabled: hostedHere && !own })
// One visit note per profile view, fire and forget: the node applies every
// budget and the switch, a failure is never retried and never shown.
@@ -996,6 +1016,15 @@ function MembroList ({ entry, ownKey, onBack, onFollowsChanged, onMessage, onRep
)
: null
+ const varandinhaRow = hostedHere && gardenOn && typeof onOpenVarandinha === 'function'
+ ? (
+ onOpenVarandinha(author)} style={({ pressed }) => [styles.linkRow, pressed && styles.pressed]}>
+
+ Varandinha
+
+
+ )
+ : null
const eventosRow = node.hosted === true && !(isPage && lifecycle.moved) && typeof onOpenEventos === 'function'
? (
onOpenEventos(author)} style={({ pressed }) => [styles.linkRow, pressed && styles.pressed]}>
@@ -1151,7 +1180,7 @@ function MembroList ({ entry, ownKey, onBack, onFollowsChanged, onMessage, onRep
about={extraShown.about ? : null}
fan={hostedHere && !own && typeof ownKey === 'string' ? : null}
top={hostedHere && !own && topRead.view && (topRead.view.rows.length > 0 || topRead.view.notice) ? : null}
- rows={blockedHere ? null : <>{listingsRow}{recadosRow}{eventosRow}{ratingsRow}>}
+ rows={blockedHere ? null : <>{listingsRow}{recadosRow}{varandinhaRow}{eventosRow}{ratingsRow}>}
avatar={{ name: who.avatarName, publicKey: author, picture: header.avatar, persist: own || isFollowed }}
title={displayText(who.title)}
subtitle={who.subtitle ? displayText(who.subtitle) : null}
diff --git a/apps/app/src/screens/Varandinha.js b/apps/app/src/screens/Varandinha.js
new file mode 100644
index 00000000..c5dae5eb
--- /dev/null
+++ b/apps/app/src/screens/Varandinha.js
@@ -0,0 +1,727 @@
+// Varandinha (entry { screen: 'varandinha', key: owner hex64 }): one balcony of
+// the cozy pot game, the own one or a neighbour's. Hosted nodes only. All
+// state is signed records in each member's own diary; the seeder index only
+// points at them, so every block shown here was read with diary.peek by the
+// node and judged by the pure model in src/garden.js (a forged pointer never
+// shows a pot). Growth runs on the reader clock: a 60 s tick redraws and no
+// request is made for it. Writes are garden.set, garden.play and garden.help,
+// each behind an explicit tap, never repeated by the screen: an uncertain
+// answer re-reads garden.state and offers nothing again by itself. No text is
+// typed anywhere, and a visitor sees only a count of who watered; the names
+// are for the owner's own balcony.
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { Pressable, ScrollView, StyleSheet, Text, View, useWindowDimensions } from 'react-native'
+import rpc, { FOLLOW_LIMIT_MAX, displayText } from '@varanda/rpc'
+import { useSafeAreaInsets } from 'react-native-safe-area-context'
+import { useBlocks } from '../blocksProvider'
+import { diaryPeekSlots } from '../engagement'
+import { readFollowKeys } from '../follow'
+import { assembleBalcony, closeConsent, discard, initialConsent, nextLoadStep, openConsent, pendingCount, pendingStart, planPeeks, provenOff, queue, revalidate, startConsent, toggleConsent } from '../garden'
+import { HELP } from '../help'
+import { gardenTime } from '../gardenClock'
+import { fetchGarden } from '../indexClient'
+import { useNames } from '../names'
+import { useNode } from '../node'
+import {
+ ACTIONS, CONSENT_LINES, CONSENT_SWITCH_LABEL, NOTICES, SOIL_LABELS, STAGE_LABELS, TITLE, STREET_TITLE, WHO_WATERED,
+ harvestVerb, pendingLabel, plantLabel, readyIn, refusalNotice, visitorLine, wateredDay
+} from '../varandinhaView'
+import { whoOf } from '../who'
+import { Btn, ConfirmStack, ErrorText, Soft, errorText, useAction, useBottomPad, useNow } from '../ui'
+import { Avatar } from '../ui/Avatar'
+import { GardenSceneView } from '../ui/GardenSceneView'
+import { Icon } from '../ui/Icon'
+import { OfflineNote } from '../ui/OfflineNote'
+import { Pill } from '../ui/Pill'
+import { RefreshableList } from '../ui/RefreshableList'
+import { Sheet } from '../ui/Sheet'
+import { EmptyState, ErrorState, Skeleton } from '../ui/States'
+import { SwitchRow } from '../ui/SwitchRow'
+import { TopActions } from '../ui/TopActions'
+import { TopBar } from '../ui/TopBar'
+import { layout, space, type } from '../ui/theme'
+import { useStyles, useTheme } from '../ui/ThemeProvider'
+
+const HEX64 = /^[0-9a-f]{64}$/
+const { GARDEN_POTS, GARDEN_HELP_PER_POT, GARDEN_SAVES_DAILY_MAX, GARDEN_HELP_ROWS } = rpc.garden
+
+// Texts the shared module has no place for.
+const BEGIN_LABEL = 'Começar'
+const LEAVE_LABEL = 'Sair da Varandinha'
+const LEAVE_TITLE = 'Sair da Varandinha?'
+const UNSAVED_TITLE = 'Sair sem guardar?'
+const OWNER_PREFIX = 'Varanda de '
+const UNSAVED_BODY = 'As ações que você ainda não guardou serão descartadas.'
+const UNSAVED_CONFIRM = 'Descartar e sair'
+const UNSAVED_STAY = 'Continuar na varanda'
+const SAVED_TOAST = 'Varanda guardada.'
+const WATERED_TOAST = 'Você regou esta varanda.'
+const OFFLINE = 'Sem conexão. Tente de novo quando a internet voltar.'
+const UNAVAILABLE = 'Não deu para abrir esta varanda agora.'
+const POT_WORD = 'Vaso '
+const EMPTY_POT = 'vazio'
+
+// A failed index read, as the person reads it.
+function indexFailure (reason) {
+ if (reason === 'not-found') return NOTICES.unreachable
+ if (reason === 'network' || reason === 'timeout') return OFFLINE
+ return UNAVAILABLE
+}
+
+// A refused or failed write, as the person reads it: an uncertain answer
+// says so, a refusal with one of the node's own sentences shows it, anything
+// else goes through errorText (never the raw message).
+function failureText (err) {
+ if (err && err.uncertain === true) return NOTICES.uncertain
+ const known = refusalNotice(err && err.message)
+ return known !== null ? known : errorText(err)
+}
+
+// The diary.peek reads of a plan, one at a time through the app-wide slots,
+// each answer handed to `sink`. A diary the node cannot reach is left unread
+// (the balcony then says it may be incomplete); any other failure stops it.
+async function peekInto (request, plan, sink, alive) {
+ for (const params of plan) {
+ if (!alive()) return
+ try {
+ const peek = await diaryPeekSlots.run(() => (alive() ? request('diary.peek', params) : null), { front: true })
+ if (!alive() || !peek || typeof peek.key !== 'string') continue
+ sink(peek)
+ } catch (err) {
+ if (err && typeof err.message === 'string' && /di[aá]rio indispon[ií]vel/i.test(err.message)) continue
+ throw err
+ }
+ }
+}
+
+// One balcony, read progressively: the owner's blocks first (the pots show as
+// soon as they are judged), then each helper's, one at a time. One index
+// refetch at most when a pointer does not resolve (nextLoadStep); a second
+// miss only marks the balcony incomplete. `onStage(result, forced)` gets each
+// state. Returns { ok: true } or { ok: false, message }; null when stale.
+async function readBalcony ({ request, owner, isBlocked, alive, onStage }) {
+ let attempt = 0
+ for (;;) {
+ const res = await fetchGarden(owner)
+ if (!alive()) return null
+ if (!res.ok) return { ok: false, message: indexFailure(res.reason) }
+ const index = res.value
+ const plan = planPeeks({ owner, index, isBlocked })
+ const ownerReads = []
+ await peekInto(request, plan.owner, (p) => ownerReads.push(p), alive)
+ if (!alive()) return null
+ const helperReads = new Map()
+ const assemble = () => assembleBalcony({ owner, index, ownerReads, helperReads, now: gardenTime(), isBlocked })
+ const first = assemble()
+ const step = nextLoadStep({ attempt, result: first })
+ if (step === 'refetch') {
+ attempt += 1
+ continue
+ }
+ const forced = step === 'incomplete'
+ onStage(first, forced)
+ if (first.isPage || !first.on) return { ok: true }
+ for (const helper of plan.helpers) {
+ const answers = []
+ try {
+ await peekInto(request, helper.batches, (p) => answers.push(p), alive)
+ } catch {
+ // A helper whose blocks cannot be read counts for nothing; the
+ // balcony reads as incomplete.
+ }
+ if (!alive()) return null
+ helperReads.set(helper.author, answers)
+ onStage(assemble(), forced)
+ }
+ return { ok: true }
+ }
+}
+
+// The own balcony as the node reads it from the own diary (garden.state).
+async function readMine (request) {
+ const r = await request('garden.state', {})
+ const base = r && r.state && Array.isArray(r.state.pots) && r.state.pots.length === GARDEN_POTS ? r.state.pots : null
+ // An unreadable count reads as every save spent, never as a fresh budget.
+ const saves = r && Number.isSafeInteger(r.savesToday) && r.savesToday >= 0 ? r.savesToday : GARDEN_SAVES_DAILY_MAX
+ const given = r && Array.isArray(r.given) ? r.given.filter((g) => !!g && typeof g === 'object').slice(0, GARDEN_HELP_ROWS) : []
+ return { on: !!r && r.on === true, base, savesToday: saves, given }
+}
+
+// The counts the reducer judges with: the node's own bound for helps
+// received (it cannot see other diaries), the own helps given as foldGiven
+// reads them.
+function countsOf (owner, base, given, now) {
+ const rows = given.map((g) => ({ seq: g.seq, record: { type: 'garden-help', to: g.to, pot: g.pot, at: g.at } }))
+ const perPot = rpc.garden.foldGiven({ self: owner, pots: base, given: rows, now }).perPot
+ return { received: new Array(GARDEN_POTS).fill(GARDEN_HELP_PER_POT), given: perPot }
+}
+
+// The own pots the node holds under the queued acts: acts that still apply
+// stay queued, the others are dropped (revalidate).
+function rebased (p, state, owner, now) {
+ if (pendingCount(p) === 0) return pendingStart(state.base)
+ const base = state.base === null ? pendingStart(null).base : state.base
+ return revalidate({ ...p, base }, now, countsOf(owner, state.base, state.given, now))
+}
+
+// The views of the own pots with the queued acts applied. A pot an act
+// touched is drawn without helps (they were counted against the saved pot and
+// the saved state decides after Guardar); the others use the helps verified
+// in the helpers' diaries, counted per pot as the fold counts them.
+function ownViews (pending, received, givenPer, now) {
+ const touched = new Set(pending.acts.map((a) => a.pot))
+ return pending.pots.map((pot, i) => {
+ const r = Array.isArray(received) && Number.isSafeInteger(received[i]) ? Math.min(Math.max(received[i], 0), GARDEN_HELP_PER_POT) : 0
+ return rpc.garden.potView(pot, now, touched.has(i) ? null : { received: r, given: givenPer[i] })
+ })
+}
+
+function potLabel (index, view, occupied) {
+ const head = POT_WORD + (index + 1) + ', '
+ if (view) return head + plantLabel(view.plant) + ', ' + STAGE_LABELS[view.stage]
+ return head + (occupied ? STAGE_LABELS[0] : EMPTY_POT)
+}
+
+function PotInfo ({ view, now }) {
+ const { colors } = useTheme()
+ const styles = useStyles(makeStyles)
+ if (!view) return null
+ return (
+
+ {plantLabel(view.plant)}
+ {[STAGE_LABELS[view.stage], 'terra ' + SOIL_LABELS[view.dry ? 'dry' : 'wet'], view.ripe ? null : readyIn(view.ripeAt, now)].filter(Boolean).join(' · ')}
+
+ )
+}
+
+function HelperRow ({ author, at, now, profile }) {
+ const styles = useStyles(makeStyles)
+ const who = whoOf(profile)
+ const title = displayText(who.title)
+ return (
+
+
+
+ {title}
+ {wateredDay(at, now)}
+
+
+ )
+}
+
+// On someone else's balcony, whose it is.
+function OwnerRow ({ owner, profile }) {
+ const styles = useStyles(makeStyles)
+ const who = whoOf(profile)
+ const title = displayText(who.title)
+ return (
+
+
+
+ {title}
+ {who.subtitle ? {displayText(who.subtitle)} : null}
+
+
+ )
+}
+
+export default function Varandinha ({ entry, ownKey, onBack, onOpenStreet, onToast, registerBackGuard }) {
+ const styles = useStyles(makeStyles)
+ const { scheme, colors } = useTheme()
+ const node = useNode()
+ const hosted = node.hosted === true
+ const names = useNames()
+ const blocks = useBlocks()
+ const now = gardenTime(useNow(60000))
+ const bottomPad = useBottomPad()
+ const insets = useSafeAreaInsets()
+ const { width } = useWindowDimensions()
+ const act = useAction()
+ const requestRef = useRef(node.request)
+ requestRef.current = node.request
+ const namesRef = useRef(names)
+ namesRef.current = names
+ const blockedRef = useRef(blocks.has)
+ blockedRef.current = blocks.has
+ const blocksKnown = blocks.loadState !== 'pending'
+ const owner = entry && typeof entry.key === 'string' ? entry.key.toLowerCase() : ''
+ const self = typeof ownKey === 'string' ? ownKey.toLowerCase() : null
+ const own = self !== null && owner === self
+
+ const [view, setView] = useState({ phase: 'loading', error: null, mine: null, following: null })
+ const [bal, setBal] = useState({ phase: 'idle', result: null, forced: false, error: null })
+ const [pending, setPending] = useState(() => pendingStart(null))
+ const [consent, setConsent] = useState(initialConsent)
+ const [potOpen, setPotOpen] = useState(null)
+ const [leaveOpen, setLeaveOpen] = useState(false)
+ const [unsaved, setUnsaved] = useState(null)
+ const [helped, setHelped] = useState(false)
+ const [notice, setNotice] = useState('')
+ const [refreshing, setRefreshing] = useState(false)
+ const seq = useRef(0)
+
+ useEffect(() => {
+ if (!own && HEX64.test(owner) && namesRef.current) namesRef.current.resolveMany([owner])
+ }, [own, owner])
+
+ const load = useCallback(async () => {
+ if (!hosted || !blocksKnown || !HEX64.test(owner)) return
+ const mine = ++seq.current
+ const alive = () => mine === seq.current
+ const request = requestRef.current
+ setView((v) => ({ ...v, phase: v.mine ? v.phase : 'loading', error: null }))
+ let state
+ try {
+ state = await readMine(request)
+ } catch (err) {
+ if (alive()) setView((v) => ({ ...v, phase: v.mine ? v.phase : 'error', error: errorText(err) }))
+ return
+ }
+ if (!alive()) return
+ // A fresh read settles an uncertain watering: garden.state lists it when
+ // it was written, and the writer rule then hides Regar.
+ setHelped((h) => (h === 'uncertain' ? false : h))
+ // A refresh keeps the queued acts that still hold on the freshly read pots.
+ if (own) setPending((p) => rebased(p, state, owner, gardenTime()))
+ if (!state.on) {
+ setView({ phase: 'ready', error: null, mine: state, following: null })
+ setBal({ phase: 'idle', result: null, forced: false, error: null })
+ return
+ }
+ setView((v) => ({ phase: 'ready', error: null, mine: state, following: own ? null : v.following }))
+ setBal((b) => ({ ...b, phase: b.result ? 'ready' : 'loading', error: null }))
+ if (!own) {
+ readFollowKeys(request, FOLLOW_LIMIT_MAX).then((set) => {
+ if (alive()) setView((v) => ({ ...v, following: set === null ? null : set.has(owner) }))
+ }, () => {})
+ }
+ let out
+ try {
+ out = await readBalcony({
+ request,
+ owner,
+ isBlocked: (key) => blockedRef.current(key),
+ alive,
+ onStage: (result, forced) => {
+ if (!alive()) return
+ if (own && namesRef.current) namesRef.current.resolveMany(result.helpers.map((h) => h.author))
+ setBal({ phase: 'ready', result, forced, error: null })
+ }
+ })
+ } catch (err) {
+ if (alive()) setBal((b) => ({ ...b, phase: b.result ? 'ready' : 'error', error: errorText(err) }))
+ return
+ }
+ if (out && !out.ok && alive()) setBal((b) => ({ ...b, phase: b.result ? 'ready' : 'error', error: out.message }))
+ }, [hosted, blocksKnown, owner, self, own])
+
+ useEffect(() => {
+ load()
+ return () => { seq.current += 1 }
+ }, [load])
+
+ const mine = view.mine
+ const counts = useMemo(
+ () => (own && mine ? countsOf(owner, mine.base, mine.given, now) : null),
+ [own, owner, mine, now]
+ )
+
+ // Growth moves on the reader clock: queued acts are judged again at every
+ // tick, and the longest prefix that still holds is kept.
+ useEffect(() => {
+ if (counts === null) return
+ setPending((p) => (pendingCount(p) === 0 ? p : revalidate(p, now, counts)))
+ }, [now, counts])
+
+ const toast = (text) => { if (typeof onToast === 'function') onToast(text) }
+
+ // One write at a time. A failure is filed as the notice and rethrown, so
+ // useAction knows whether it was uncertain; nothing is sent again.
+ const write = (method, params) => act.run(async () => {
+ try {
+ return await requestRef.current(method, params)
+ } catch (err) {
+ setNotice(failureText(err))
+ throw err
+ }
+ })
+
+ // The own balcony as the node holds it after a write. A failed read keeps
+ // the write's own notice (an uncertain answer says to check first).
+ const reread = async () => {
+ try {
+ const state = await readMine(requestRef.current)
+ setView((v) => ({ ...v, mine: state }))
+ return state
+ } catch (err) {
+ setNotice((n) => n || errorText(err))
+ return null
+ }
+ }
+
+ const begin = async () => {
+ if (act.pending) return
+ const next = startConsent(consent)
+ if (next === consent) return
+ setConsent(next)
+ setNotice('')
+ const r = await write('garden.set', { on: true })
+ if (r.ok) {
+ setConsent(closeConsent())
+ setNotice('')
+ load()
+ return
+ }
+ setConsent((c) => ({ ...c, busy: false }))
+ if (r.uncertain) {
+ const state = await reread()
+ if (state && state.on) {
+ setConsent(closeConsent())
+ load()
+ }
+ }
+ }
+
+ const leave = async () => {
+ if (act.pending) return
+ setNotice('')
+ const r = await write('garden.set', { on: false })
+ if (!r.ok && !r.uncertain) return
+ const state = r.ok ? { on: false, base: null, savesToday: 0, given: [] } : await reread()
+ if (state === null) return
+ setLeaveOpen(false)
+ if (state.on) {
+ // The node still reads the balcony as on: the leave may have stopped
+ // halfway. The uncertain notice stays and the balcony is read again,
+ // with the queued acts that still hold.
+ load()
+ return
+ }
+ setView((v) => ({ ...v, mine: state }))
+ setPending(pendingStart(null))
+ setBal({ phase: 'idle', result: null, forced: false, error: null })
+ }
+
+ const exhausted = mine !== null && mine.savesToday >= GARDEN_SAVES_DAILY_MAX
+
+ const save = async () => {
+ if (act.pending || pendingCount(pending) === 0 || exhausted) return
+ setNotice('')
+ const r = await write('garden.play', { acts: pending.acts })
+ if (!r.ok && !r.uncertain) return
+ // The batch leaves the queue whatever the read below finds, so it is
+ // never sent twice. A saved batch shows the pots the node answered with.
+ const saved = r.ok && r.value && r.value.state && Array.isArray(r.value.state.pots) && r.value.state.pots.length === GARDEN_POTS ? r.value.state.pots : null
+ setPending((p) => pendingStart(saved !== null ? saved : p.base))
+ if (r.ok) toast(SAVED_TOAST)
+ const state = await reread()
+ if (state !== null) setPending((p) => rebased(p, state, owner, gardenTime()))
+ }
+
+ const tap = (op, index, plant) => {
+ if (act.pending) return
+ const action = plant === undefined ? { op, pot: index } : { op, pot: index, plant }
+ const next = queue(pending, action, gardenTime(), counts)
+ setPending(next)
+ setNotice(next.refused === null ? '' : NOTICES.invalid)
+ if (next.refused === null) setPotOpen(null)
+ }
+
+ const water = async (index) => {
+ if (act.pending || helped) return
+ setNotice('')
+ const r = await write('garden.help', { to: owner, pot: index })
+ if (r.ok) {
+ setHelped('ok')
+ setPotOpen(null)
+ toast(WATERED_TOAST)
+ } else if (r.uncertain) {
+ // The help may have been written: no second button for it.
+ setHelped('uncertain')
+ }
+ }
+
+ // Leaving with queued acts asks first; nothing is written either way. A
+ // batch already on its way to the node is not unsaved: leaving then asks
+ // nothing, and the write goes on.
+ const unsavedActs = () => pendingCount(pending) > 0 && !act.pending
+ const guard = (go) => {
+ if (typeof go !== 'function') return
+ if (unsavedActs()) setUnsaved({ go })
+ else go()
+ }
+ // Android Back and Escape ask the same way. The native swipe back and the
+ // browser Back consult no guard, as for Anunciar.
+ const backRef = useRef(null)
+ backRef.current = () => {
+ if (!unsavedActs() || typeof onBack !== 'function') return false
+ setUnsaved({ go: onBack })
+ return true
+ }
+ useEffect(() => {
+ if (typeof registerBackGuard !== 'function') return
+ return registerBackGuard(() => backRef.current())
+ }, [registerBackGuard])
+
+ const bar = guard(onBack)} right={} />
+ if (!hosted) {
+ return (
+
+ {bar}
+
+
+ )
+ }
+ if (!HEX64.test(owner)) {
+ return (
+
+ {bar}
+
+
+ )
+ }
+ if (view.phase === 'loading') {
+ return (
+
+ {bar}
+
+
+
+ )
+ }
+ if (view.phase === 'error') {
+ return (
+
+ {bar}
+
+
+
+ )
+ }
+
+ const consentSheet = (
+ setConsent(closeConsent())} dismissable={!consent.busy && !act.pending} title={TITLE}>
+
+ {CONSENT_LINES.map((line) => {line})}
+ setConsent(toggleConsent(consent))} disabled={consent.busy} />
+ {notice}
+
+
+
+ )
+
+ if (!mine || !mine.on) {
+ return (
+
+ {bar}
+
+ { setNotice(''); setConsent(openConsent()) }} />
+ {consentSheet}
+
+ )
+ }
+
+ const result = bal.result
+ const page = !!result && result.isPage
+ // A balcony reads as off only when its blocks were read in full: an unread
+ // or stale block, or an index still being built, proves nothing.
+ const away = provenOff(result, bal.forced) && bal.phase === 'ready'
+ const unproven = !!result && !result.isPage && !result.on && !provenOff(result, bal.forced)
+ if (!own && (page || away)) {
+ return (
+
+ {bar}
+
+
+
+ )
+ }
+ if (!own && unproven) {
+ return (
+
+ {bar}
+
+
+
+ )
+ }
+
+ // A neighbour's pots are shown only once the owner's blocks were judged.
+ if (!own && !result) {
+ return (
+
+ {bar}
+
+ {bal.phase === 'error' ? : }
+
+ )
+ }
+
+ const pending6 = pendingCount(pending)
+ const helpers = result && !page ? result.helpers : []
+ const givenPer = own && counts ? counts.given : new Array(GARDEN_POTS).fill(0)
+ const views = own
+ ? ownViews(pending, result && !page ? result.received : null, givenPer, now)
+ : (result && !page && result.on ? result.pots : new Array(GARDEN_POTS).fill(null))
+ const labels = views.map((v, i) => potLabel(i, v, own ? !!pending.pots[i] : false))
+ const notes = []
+ if (result && !page) {
+ if (result.indexing) notes.push(NOTICES.indexing)
+ else if (!result.loading && (result.incomplete || result.stale || bal.forced)) notes.push(NOTICES.incomplete)
+ }
+ if (exhausted && own) notes.push(NOTICES.saves)
+
+ // The node's own writer rule over the waterings garden.state listed: a
+ // balcony already watered today, or a spent daily budget, offers no Regar.
+ const allowed = !own && mine && self !== null && view.following === true &&
+ rpc.garden.helpAllowed({ self, to: owner, follows: new Set([owner]), own: mine.given, now }).ok === true
+ const canHelp = allowed && result !== null && result.on === true && mine.on && !helped
+ const sheetView = potOpen === null ? null : views[potOpen]
+ const occupied = potOpen !== null && own ? !!pending.pots[potOpen] : !!sheetView
+
+ const scene = (
+
+ { setNotice(''); setPotOpen(i) }} />
+
+ )
+
+ const header = (
+
+ {!own ? : null}
+ {scene}
+ {notes.map((n) => {n})}
+ {notice ? {notice} : null}
+ {!own && result && !result.loading && !page ? {visitorLine(result.helpers.length + (helped === 'ok' && !result.helpers.some((h) => h.author === self) ? 1 : 0))} : null}
+ {own && typeof onOpenStreet === 'function'
+ ? (
+ guard(onOpenStreet)}
+ style={({ pressed }) => [styles.streetRow, pressed && styles.pressed]}
+ >
+
+ {STREET_TITLE}
+
+
+ )
+ : null}
+ {own ? {WHO_WATERED} : null}
+
+ )
+
+ let empty = null
+ if (own) {
+ if (bal.phase === 'error') empty =
+ else if (!result || result.loading) empty =
+ else empty = {visitorLine(0)}
+ }
+ const footer = own
+ ? { setNotice(''); setLeaveOpen(true) }} />
+ : null
+
+ return (
+
+ {bar}
+
+ h.author + ':' + h.seq}
+ renderItem={({ item }) => }
+ extraData={{ now, notice, names }}
+ ListHeaderComponent={header}
+ ListEmptyComponent={empty}
+ ListFooterComponent={footer}
+ contentContainerStyle={{ paddingBottom: bottomPad }}
+ onRefresh={async () => {
+ setRefreshing(true)
+ try { await load() } finally { setRefreshing(false) }
+ }}
+ refreshing={refreshing}
+ atEnd
+ />
+ {own && pending6 > 0
+ ? (
+
+ {pendingLabel(pending6)}
+
+ { setPending(discard(pending)); setNotice('') }} />
+
+
+
+ )
+ : null}
+ setPotOpen(null)} dismissable={!act.pending} title={potOpen === null ? '' : POT_WORD + (potOpen + 1)}>
+
+
+ {own && potOpen !== null && !occupied
+ ? (
+ <>
+ {ACTIONS.plant}
+ {rpc.garden.GARDEN_PLANTS.map((p) => (
+ tap('plant', potOpen, p.id)} />
+ ))}
+ >
+ )
+ : null}
+ {own && potOpen !== null && occupied
+ ? (
+ <>
+ {sheetView && sheetView.canWater ? tap('water', potOpen)} /> : null}
+ {sheetView && sheetView.ripe ? tap('harvest', potOpen)} /> : null}
+ tap('clear', potOpen)} />
+ >
+ )
+ : null}
+ {!own && potOpen !== null && canHelp && sheetView && !sheetView.ripe
+ ? water(potOpen)} />
+ : null}
+ {notice}
+
+
+ setLeaveOpen(false)} dismissable={!act.pending} title={LEAVE_TITLE}>
+
+ {CONSENT_LINES[4]}
+ {notice}
+ }
+ cancel={ setLeaveOpen(false)} disabled={act.pending} />}
+ />
+
+
+ setUnsaved(null)} title={UNSAVED_TITLE}>
+
+ {UNSAVED_BODY}
+ { const go = unsaved.go; setUnsaved(null); setPending(discard(pending)); go() }} />}
+ cancel={ setUnsaved(null)} />}
+ />
+
+
+ {consentSheet}
+
+ )
+}
+
+const makeStyles = (colors) => StyleSheet.create({
+ screen: { flex: 1, backgroundColor: colors.bg },
+ scene: { alignItems: 'center' },
+ note: { paddingHorizontal: space.lg, paddingVertical: space.sm },
+ count: { ...type.rowName },
+ more: { paddingHorizontal: space.lg, paddingVertical: space.lg, alignItems: 'flex-start' },
+ section: { ...type.section, color: colors.soft, paddingHorizontal: space.lg, paddingTop: space.lg, paddingBottom: space.xs },
+ streetRow: { flexDirection: 'row', alignItems: 'center', gap: space.md, minHeight: layout.hit, paddingVertical: space.sm, paddingHorizontal: space.lg },
+ streetLabel: { ...type.rowName, color: colors.ink, flex: 1 },
+ pressed: { opacity: 0.6 },
+ helper: { flexDirection: 'row', alignItems: 'center', gap: space.md, minHeight: layout.hit, paddingVertical: space.sm, paddingHorizontal: space.lg },
+ who: { flex: 1, minWidth: 0 },
+ name: { ...type.rowName, color: colors.ink },
+ when: { ...type.caption, color: colors.soft },
+ pendingBar: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', gap: space.md, paddingHorizontal: space.lg, paddingVertical: space.sm, borderTopWidth: 1, borderTopColor: colors.line, backgroundColor: colors.card },
+ pendingText: { ...type.rowName, flexShrink: 1 },
+ pendingActions: { flexDirection: 'row', alignItems: 'center', gap: space.sm },
+ potInfo: { gap: space.xs },
+ potName: { ...type.postName },
+ sheetBody: { gap: space.md, paddingHorizontal: space.lg, paddingBottom: space.lg }
+})
diff --git a/apps/app/src/screens/VarandinhaRua.js b/apps/app/src/screens/VarandinhaRua.js
new file mode 100644
index 00000000..9e6d1e98
--- /dev/null
+++ b/apps/app/src/screens/VarandinhaRua.js
@@ -0,0 +1,189 @@
+// Varandas da rua (entry { screen: 'varandinha-rua' }): the balconies of the
+// people the viewer follows who play the Varandinha, in the seeder's key
+// order, 20 a page. Hosted nodes only. The list is a seeder claim: a key
+// shows only when the viewer's own follow.list holds it, and each balcony is
+// read and verified when it is opened (Varandinha.js). A next page loads
+// only on an explicit tap, never as a chain, and nothing here writes.
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { Pressable, StyleSheet, Text, View } from 'react-native'
+import { FOLLOW_LIMIT_MAX, displayText } from '@varanda/rpc'
+import { useBlocks } from '../blocksProvider'
+import { readFollowKeys } from '../follow'
+import { streetKeys } from '../garden'
+import { fetchGardenStreet } from '../indexClient'
+import { useNames } from '../names'
+import { useNode } from '../node'
+import { NOT_HOSTED } from '../pessoas'
+import { whoOf } from '../who'
+import { NOTICES, STREET_TITLE } from '../varandinhaView'
+import { Soft, useBottomPad } from '../ui'
+import { Avatar } from '../ui/Avatar'
+import { OfflineNote } from '../ui/OfflineNote'
+import { Pill } from '../ui/Pill'
+import { RefreshableList } from '../ui/RefreshableList'
+import { EmptyState, ErrorState, Skeleton } from '../ui/States'
+import { TopBar } from '../ui/TopBar'
+import { layout, space, type } from '../ui/theme'
+import { useStyles } from '../ui/ThemeProvider'
+
+const HEX64 = /^[0-9a-f]{64}$/
+const OFFLINE = 'Sem conexão. Tente de novo quando a internet voltar.'
+const UNAVAILABLE = 'Não deu para abrir as varandas da rua agora.'
+const MORE = 'Carregar mais'
+const EMPTY_TITLE = 'Nenhuma varanda por aqui ainda'
+const EMPTY_BODY = 'Quando alguém que você segue entrar na Varandinha, a varanda aparece aqui.'
+const ROW_HINT = 'ver a varanda de '
+
+// A failed index read, as the person reads it.
+function failureOf (reason) {
+ if (reason === 'not-found') return NOTICES.unreachable
+ if (reason === 'network' || reason === 'timeout') return OFFLINE
+ return UNAVAILABLE
+}
+
+function StreetRow ({ keyHex, profile, onOpen }) {
+ const styles = useStyles(makeStyles)
+ const who = whoOf(profile)
+ const title = displayText(who.title)
+ return (
+ onOpen(keyHex)}
+ style={({ pressed }) => [styles.row, pressed && styles.pressed]}
+ >
+
+
+ {title}
+ {who.subtitle ? {displayText(who.subtitle)} : null}
+
+
+ )
+}
+
+export default function VarandinhaRua ({ ownKey, onBack, onOpenBalcony }) {
+ const styles = useStyles(makeStyles)
+ const node = useNode()
+ const hosted = node.hosted === true
+ const names = useNames()
+ // The names cache changes as profiles arrive; the list is not read again
+ // for that.
+ const namesRef = useRef(names)
+ namesRef.current = names
+ const blocks = useBlocks()
+ const bottom = useBottomPad()
+ const blockedRef = useRef(blocks.has)
+ blockedRef.current = blocks.has
+ const blocksKnown = blocks.loadState !== 'pending'
+ const self = typeof ownKey === 'string' && HEX64.test(ownKey.toLowerCase()) ? ownKey.toLowerCase() : null
+ const [view, setView] = useState({ phase: 'loading', keys: [], next: null, error: null, more: false, indexing: false, complete: true })
+ const [refreshing, setRefreshing] = useState(false)
+ const held = useRef({ next: null, follows: null })
+ const seq = useRef(0)
+ const requestRef = useRef(node.request)
+ requestRef.current = node.request
+
+ const load = useCallback(async (more) => {
+ if (!hosted || !blocksKnown || self === null) return
+ const mine = ++seq.current
+ const alive = () => mine === seq.current
+ const cursor = more ? held.current.next : null
+ setView((v) => ({ ...v, phase: more || v.keys.length > 0 ? v.phase : 'loading', more, error: null }))
+ // The follow set is read again on every first page and kept for the next
+ // ones; a failed read shows no unchecked key.
+ const known = more ? held.current.follows : null
+ const [res, follows] = await Promise.all([
+ fetchGardenStreet(self, cursor),
+ known || readFollowKeys(requestRef.current, FOLLOW_LIMIT_MAX)
+ ])
+ if (!alive()) return
+ if (!res.ok || follows === null) {
+ const error = res.ok ? UNAVAILABLE : failureOf(res.reason)
+ setView((v) => ({ ...v, phase: v.keys.length > 0 ? 'ready' : 'error', more: false, error }))
+ return
+ }
+ held.current = { next: res.value.next, follows }
+ const fresh = streetKeys(res.value.items, follows)
+ if (namesRef.current) namesRef.current.resolveMany(fresh)
+ setView((v) => {
+ const seen = new Set(more ? v.keys : [])
+ const keys = more ? v.keys.slice() : []
+ for (const k of fresh) {
+ if (seen.has(k)) continue
+ seen.add(k)
+ keys.push(k)
+ }
+ return { phase: 'ready', keys, next: res.value.next, error: null, more: false, indexing: res.value.indexing, complete: res.value.complete }
+ })
+ }, [hosted, blocksKnown, self])
+
+ useEffect(() => {
+ load(false)
+ return () => { seq.current += 1 }
+ }, [load])
+
+ const bar =
+ if (!hosted) {
+ return (
+
+ {bar}
+
+
+ )
+ }
+
+ // The viewer and blocked people never show, whenever the block list changes.
+ const rows = view.keys.filter((k) => k !== self && !blockedRef.current(k))
+ let empty = null
+ if (self === null) empty =
+ else if (view.phase === 'loading') empty =
+ else if (view.phase === 'error') empty = load(false)} />
+ // While the index is still built or the answer is partial, the note says so
+ // instead of an empty street.
+ else if (view.next === null && !view.indexing && view.complete !== false) empty =
+
+ let note = null
+ if (view.phase === 'ready') {
+ if (view.error) note = view.error
+ else if (view.indexing) note = NOTICES.indexing
+ else if (view.complete === false) note = NOTICES.incomplete
+ }
+ const header = note ? {note} : null
+ const footer = view.next && view.phase === 'ready'
+ ? load(true)} />
+ : null
+
+ return (
+
+ {bar}
+
+ k}
+ renderItem={({ item }) => }
+ ListHeaderComponent={header}
+ ListEmptyComponent={empty}
+ ListFooterComponent={footer}
+ contentContainerStyle={{ paddingBottom: bottom }}
+ onRefresh={async () => {
+ setRefreshing(true)
+ try { await load(false) } finally { setRefreshing(false) }
+ }}
+ refreshing={refreshing}
+ atEnd
+ />
+
+ )
+}
+
+const makeStyles = (colors) => StyleSheet.create({
+ screen: { flex: 1, backgroundColor: colors.bg },
+ notice: { paddingHorizontal: space.lg, paddingVertical: space.sm },
+ more: { paddingHorizontal: space.lg, paddingVertical: space.md, alignItems: 'flex-start' },
+ row: { flexDirection: 'row', alignItems: 'center', gap: space.md, minHeight: layout.hit, paddingVertical: space.sm, paddingHorizontal: space.lg },
+ pressed: { opacity: 0.6 },
+ who: { flex: 1, minWidth: 0 },
+ name: { ...type.rowName, color: colors.ink },
+ handle: { ...type.caption, color: colors.soft }
+})
diff --git a/apps/app/src/tabs.js b/apps/app/src/tabs.js
index 4aa767be..26c4dd99 100644
--- a/apps/app/src/tabs.js
+++ b/apps/app/src/tabs.js
@@ -29,7 +29,7 @@ const FEIRA_SCREENS = new Set(['anuncio', 'anunciar', 'editar-anuncio', 'avaliar
// Screens with nothing to publish on: the Depoimentos management screen,
// the Posts salvos list, an Assunto page, a Recados page, the fan list, the
// Melhores amigos editor and the full-screen Momentos viewer. Conversa has its own reply bar.
-const NO_POST_SCREENS = new Set(['depoimentos', 'momentos', 'conversa', 'salvos', 'assunto', 'recados', 'fas', 'melhores-amigos', 'eventos', 'visitas'])
+const NO_POST_SCREENS = new Set(['depoimentos', 'momentos', 'conversa', 'salvos', 'assunto', 'recados', 'fas', 'melhores-amigos', 'eventos', 'visitas', 'varandinha', 'varandinha-rua'])
// The floating "publicar" button belongs to posts: it is hidden on the
// Conversas and Feira tabs, on their screens and on NO_POST_SCREENS. `screen`
diff --git a/apps/app/src/vitrine/request.js b/apps/app/src/vitrine/request.js
index ad96cc52..8e890774 100644
--- a/apps/app/src/vitrine/request.js
+++ b/apps/app/src/vitrine/request.js
@@ -344,11 +344,12 @@ export function createVitrineRequest (fixtures, options) {
// Varandinha (5.157 to 5.160): the own balcony is read from the own diary
// records, so the fixtures, a play, a help and a leave all agree with
// diary.peek and the /index/garden answers. The rules are rpc.garden, on
- // the demo clock; answered dates move with options.clock like momentos.
+ // the demo clock. Unlike momentos, answered dates stay on that clock: a
+ // peeked garden block cannot move, so the app reads the demo clock for the
+ // whole game in a Vitrine bundle (src/gardenClock.js).
const gardenOf = (type) => (logs.get(data.own) || []).filter((e) => e.record.type === type && !deleted.has(`${data.own}:${e.seq}`)).sort((a, b) => b.seq - a.seq)
const gardenOn = () => gardenOf('garden')[0]?.record.on === true
- const shownPot = (p) => p === null ? null : { ...p, at: shown(p.at), water: shown(p.water) }
- const gardenShape = (e) => e ? { seq: e.seq, pots: e.record.pots.map(shownPot), n: e.record.n, at: shown(e.record.at) } : null
+ const gardenShape = (e) => e ? { seq: e.seq, pots: e.record.pots.map((p) => p === null ? null : { ...p }), n: e.record.n, at: e.record.at } : null
const gardenTombstone = (seq) => deleted.set(`${data.own}:${seq}`, append({ type: 'delete', seq, at: stamp() }))
// Latest wins, as the node's publishLatest: every earlier live block of the
// type is tombstoned before the new one.
@@ -945,7 +946,7 @@ export function createVitrineRequest (fixtures, options) {
savesToday: state && Date.parse(state.record.at) >= today ? state.record.n : 0,
helpsToday: helps.filter((h) => h.atMs >= today).length,
given: helps.filter((h) => h.atMs >= now - rpc.garden.GARDEN_HELP_WINDOW_MS && h.atMs <= now + rpc.garden.GARDEN_MAX_FUTURE_MS)
- .slice(0, rpc.garden.GARDEN_HELP_ROWS).map(({ seq, to, pot, at }) => ({ seq, to, pot, at: shown(at) }))
+ .slice(0, rpc.garden.GARDEN_HELP_ROWS).map(({ seq, to, pot, at }) => ({ seq, to, pot, at }))
}
},
'garden.play': ({ acts }) => {
diff --git a/apps/app/test/composePolish.test.js b/apps/app/test/composePolish.test.js
index bfbf888d..c52aa082 100644
--- a/apps/app/test/composePolish.test.js
+++ b/apps/app/test/composePolish.test.js
@@ -29,6 +29,7 @@ test('settings group every row and keep the existing advanced toggle last', (t)
['{WALL_TITLE}', "() => onNavigate('recados')"],
['{DEVICES_TITLE}', "() => onNavigate('aparelhos')"],
['{VISITAS_TITLE}', 'openVisitasSheet'],
+ ["'Varandinha'", 'openVarandinha'],
['{CONSENT_SWITCH_LABEL}', '() => setConsent(toggleConsent(consent))'],
["'Convidar pessoas'", "() => onNavigate('convites')"],
["'Páginas'", 'openPaginas'],
diff --git a/apps/app/test/feiraCompose.test.js b/apps/app/test/feiraCompose.test.js
index b54064d2..31b65967 100644
--- a/apps/app/test/feiraCompose.test.js
+++ b/apps/app/test/feiraCompose.test.js
@@ -141,27 +141,30 @@ test('feiraCompose: back guard steps back and protects a draft at the first step
test('feiraCompose: App routes hardware back and Escape through the active guard', (t) => {
const src = source('App.js')
- t.ok(src.includes('const backGuardRef = useRef(null)'))
+ t.ok(src.includes('const backGuardsRef = useRef(new Set())'))
+ t.ok(src.includes('for (const fn of backGuardsRef.current) if (fn() === true) return true'), 'any registered guard may answer')
const hardwareStart = src.indexOf("BackHandler.addEventListener('hardwareBackPress'")
const hardware = src.slice(hardwareStart, src.indexOf('return () => sub.remove()', hardwareStart))
- t.ok(/if \(helpOpenRef.current \|\| sheetOpenRef.current\) return false\s+if \(backGuardRef.current\?\.\(\) === true\) return true/.test(hardware))
+ t.ok(/if \(helpOpenRef.current \|\| sheetOpenRef.current\) return false\s+if \(guarded\(\)\) return true/.test(hardware))
const escape = src.slice(src.indexOf('const onKey = (event) =>'), src.indexOf("globalThis.addEventListener('keydown', onKey)"))
- t.ok(/sheetOpenRef.current\) return\s+if \(backGuardRef.current\?\.\(\) === true\) \{\s+event.preventDefault\(\)\s+return/.test(escape))
+ t.ok(/sheetOpenRef.current\) return\s+if \(guarded\(\)\) \{\s+event.preventDefault\(\)\s+return/.test(escape))
t.ok(src.includes('const guardRegistrar = entryHandlers.current.for(i + \':anunciar\', { handleRegisterBackGuard: (fn) => registerBackGuard(() => stackRef.current.length - 1 === i && stackRef.current[i].screen === \'anunciar\' && fn()) }).handleRegisterBackGuard') && src.includes('registerBackGuard={guardRegistrar}'), 'hidden and departing screens cannot consume back')
+ t.ok(src.includes('const guardRegistrar = entryHandlers.current.for(i + \':varandinha\', { handleRegisterBackGuard: (fn) => registerBackGuard(() => stackRef.current.length - 1 === i && stackRef.current[i].screen === \'varandinha\' && fn()) }).handleRegisterBackGuard'), 'a hidden Varandinha cannot consume back')
const match = src.match(/const registerBackGuard = useCallback\(\(fn\) => \{([\s\S]*?)\n {2}\}, \[\]\)/)
t.ok(match, 'registration returns an owned cleanup')
if (!match) return
- const ref = { current: null }
- const register = vm.runInNewContext('(fn) => {' + match[1] + '}', { backGuardRef: ref })
+ const ref = { current: new Set() }
+ const register = vm.runInNewContext('(fn) => {' + match[1] + '}', { backGuardsRef: ref })
const first = () => true
const second = () => false
const clearFirst = register(first)
- t.is(ref.current, first)
+ t.ok(ref.current.has(first))
const clearSecond = register(second)
+ t.is(ref.current.size, 2, 'each screen keeps its own guard')
clearFirst()
- t.is(ref.current, second, 'an old unmount preserves the newer guard')
+ t.alike([...ref.current], [second], 'an old unmount preserves the newer guard')
clearSecond()
- t.is(ref.current, null, 'unmount clears its own guard')
+ t.is(ref.current.size, 0, 'unmount clears its own guard')
})
const form = (extra = {}) => ({
diff --git a/apps/app/test/garden.test.js b/apps/app/test/garden.test.js
index 4267efc1..55bcb06a 100644
--- a/apps/app/test/garden.test.js
+++ b/apps/app/test/garden.test.js
@@ -490,3 +490,58 @@ test('assembleBalcony folds nothing while block 1 or 2 is unread', async (t) =>
const page = assembleBalcony({ owner: OWNER, index: baseIndex(), ownerReads: [peek(OWNER, [e(1, { type: 'page-roster' }), ...body], { missing: [2] })], helperReads: new Map(), now: NOW })
t.is(page.isPage, true)
})
+
+test('the garden clock is the reader clock outside the Vitrine', async (t) => {
+ const { gardenTime } = await import('../src/gardenClock.js')
+ t.is(gardenTime(NOW), NOW)
+ const before = Date.now()
+ const read = gardenTime()
+ t.ok(read >= before && read <= Date.now())
+})
+
+test('assembleBalcony counts a neighbour watering one pot on two days twice', async (t) => {
+ const { assembleBalcony } = await import('../src/garden.js')
+ const planted = NOW - 30 * H
+ const ownerReads = [peek(OWNER, [e(1, { type: 'profile' }), e(3, flag()), e(4, state(potsWith(0, pot('espada', planted))))])]
+ const helps = [helpRow(BOB, 9, 5), helpRow(BOB, 12, 5)]
+ const reads = new Map([[BOB, peek(BOB, [e(5, follow(OWNER)), e(9, help(OWNER, 0, NOW - 20 * H)), e(12, help(OWNER, 0, NOW - H))])]])
+ const r = assembleBalcony({ owner: OWNER, index: baseIndex({ helps }), ownerReads, helperReads: reads, now: NOW })
+ t.is(r.helpers.length, 1, 'one row per neighbour')
+ t.is(r.helpers[0].seq, 12)
+ t.alike(r.received, [2, 0, 0, 0, 0, 0])
+ t.is(r.pots[0].ripeAt, planted + 48 * H - 4 * H, 'both days shorten the wait')
+ const off = assembleBalcony({ owner: OWNER, index: baseIndex({ helps }), ownerReads: [peek(OWNER, [e(1, { type: 'profile' }), e(3, flag(false)), e(4, state(potsWith(0, pot('espada', planted))))])], helperReads: reads, now: NOW })
+ t.alike(off.received, [0, 0, 0, 0, 0, 0])
+ t.alike(assembleBalcony({}).received, [0, 0, 0, 0, 0, 0])
+})
+
+test('provenOff is true only for an off balcony read in full', async (t) => {
+ const { assembleBalcony, provenOff } = await import('../src/garden.js')
+ const offReads = [peek(OWNER, [e(1, { type: 'profile' }), e(3, flag(false)), e(4, state(ownerPots()))])]
+ const off = assembleBalcony({ owner: OWNER, index: baseIndex(), ownerReads: offReads, helperReads: new Map(), now: NOW })
+ t.is(provenOff(off, false), true)
+ t.is(provenOff(off, true), false, 'a second stale pointer proves nothing')
+ t.is(provenOff({ ...off, indexing: true }, false), false)
+ t.is(provenOff({ ...off, stale: true }, false), false)
+ const unread = assembleBalcony({ owner: OWNER, index: baseIndex(), ownerReads: [peek(OWNER, [e(3, flag())], { missing: [1, 2] })], helperReads: new Map(), now: NOW })
+ t.is(unread.on, false)
+ t.is(provenOff(unread, false), false, 'unread first blocks read as unknown, not off')
+ const partial = assembleBalcony({ owner: OWNER, index: baseIndex({ complete: false }), ownerReads: offReads, helperReads: new Map(), now: NOW })
+ t.is(provenOff(partial, false), false)
+ const on = assembleBalcony({ owner: OWNER, index: baseIndex(), ownerReads: ownerRead(), helperReads: new Map(), now: NOW })
+ t.is(provenOff(on, false), false)
+ t.is(provenOff(null, false), false)
+ t.is(provenOff({ ...off, isPage: true }, false), false)
+})
+
+test('streetKeys offers only followed keys, once each, in the seeder order', async (t) => {
+ const { streetKeys } = await import('../src/garden.js')
+ const follows = new Set([BOB, CAROL])
+ const items = [{ key: DAVE, on: 1 }, { key: CAROL, on: 2 }, { key: BOB.toUpperCase(), on: 3 }, { key: CAROL, on: 4 }]
+ t.alike(streetKeys(items, follows), [CAROL, BOB], 'a key the viewer does not follow never shows')
+ t.alike(streetKeys([{ key: 'b'.repeat(63) }, { key: 7 }, null, 'x', { key: BOB }], follows), [BOB], 'a malformed row is dropped')
+ t.alike(streetKeys(items, null), [], 'without a follow set nothing is offered')
+ t.alike(streetKeys(items, [BOB, CAROL]), [], 'a follow array is not a follow set')
+ t.alike(streetKeys(null, follows), [])
+ t.alike(streetKeys(items, new Set()), [])
+})
diff --git a/apps/app/test/legal.test.js b/apps/app/test/legal.test.js
index 4a3e1ecc..77c6c06a 100644
--- a/apps/app/test/legal.test.js
+++ b/apps/app/test/legal.test.js
@@ -7,9 +7,9 @@ const load = () => import('../src/legal.js')
test('legal: version, date and review note', async (t) => {
const { LEGAL_VERSION, LEGAL_DATE, REVIEW_NOTE } = await load()
- t.is(LEGAL_VERSION, 77)
+ t.is(LEGAL_VERSION, 78)
t.is(LEGAL_DATE, '17/11/2026')
- t.is(REVIEW_NOTE, 'Versão 77, sujeita a revisão jurídica. Não é parecer jurídico.')
+ t.is(REVIEW_NOTE, 'Versão 78, sujeita a revisão jurídica. Não é parecer jurídico.')
})
test('legal: this version describes music covers as never stored', async (t) => {
@@ -363,7 +363,7 @@ test('legal: privacy identifies unresolved retention and contact', async (t) =>
test('legal: published text is pinned to its acceptance version', async (t) => {
const { LEGAL_VERSION, TERMS, PRIVACY } = await load()
const digest = createHash('sha256').update(JSON.stringify({ LEGAL_VERSION, TERMS, PRIVACY })).digest('hex')
- t.is(digest, 'd81d40a05d10940ff41d82114a787d45b1f483c62933f1da9255106ec45e6851', 'o texto mudou: suba LEGAL_VERSION (e TERMS_VERSION em @varanda/core lib/terms.js) e atualize este digest')
+ t.is(digest, 'cd7e977121ae044b4df027e16ba0563e983238025c647376e6d0ca48c043f9c6', 'o texto mudou: suba LEGAL_VERSION (e TERMS_VERSION em @varanda/core lib/terms.js) e atualize este digest')
})
test('legal: version 41 describes group and conversation reactions and chat formatting', async (t) => {
@@ -893,6 +893,30 @@ test('legal: version 76 describes connected devices and the periodic key change'
t.ok(text(TERMS).includes('fica trancado até alguém entrar de novo com a passkey'), 'the disconnected device locks')
})
+test('legal: version 78 describes Varandinha', async (t) => {
+ const { TERMS, PRIVACY } = await load()
+ const text = (doc) => doc.sections.flatMap(({ paragraphs }) => paragraphs).join(' ')
+ for (const doc of [TERMS, PRIVACY]) {
+ t.ok(text(doc).includes('a Varandinha é opcional e começa desligada') || text(doc).includes('A Varandinha é um jogo opcional e começa desligada'), 'optional and off by default')
+ t.ok(text(doc).includes('a pessoa cuja planta você regou vê o seu nome') || text(doc).includes('A pessoa cuja planta você regou vê o seu nome'), 'the watered person sees the name')
+ t.ok(text(doc).includes('recompensa sorteada, ranking nem prêmio'), 'no random reward, ranking or prize')
+ t.ok(text(doc).includes('nenhuma notificação pede para alguém voltar'), 'nothing asks anyone to come back')
+ t.ok(text(doc).includes('cópias que outras pessoas já buscaram podem continuar'), 'fetched copies may remain')
+ t.ok(text(doc).includes('Sair apaga só os seus próprios registros: as regas que vizinhos fizeram na sua varanda ficam no diário deles, e só quem regou pode apagá-las.'), 'leaving deletes only the own records')
+ t.absent(text(doc).includes('\u2014'), 'no em dash')
+ }
+ t.ok(text(TERMS).includes('O estado de cada varanda é declarado por quem joga e não é conferido por ninguém.'), 'terms: declared, not verified')
+ t.ok(text(PRIVACY).includes('O estado do jogo é declarado por cada pessoa e não é conferido'), 'privacy: declared, not verified')
+ t.ok(text(PRIVACY).includes('e fica sabendo qual varanda o seu aparelho abre'), 'privacy: the seeder sees which balcony is opened')
+ t.ok(text(PRIVACY).includes('sem guardar planta nem nome'), 'privacy: pointers only')
+ t.ok(text(PRIVACY).includes('A cada nova rega, o app marca como apagadas até sete das suas regas com mais de cerca de três dias; as que sobrarem continuam públicas até as regas seguintes ou até você sair.'), 'privacy: each watering prunes at most seven helps older than about three days')
+ t.ok(text(TERMS).includes('deixa no seu diário um registro público de que o jogo foi desligado'), 'terms: leaving keeps a public off flag')
+ t.ok(text(PRIVACY).includes('deixa no diário o registro público de desligado'), 'privacy: leaving keeps a public off flag')
+ t.ok(text(PRIVACY).includes('inclusive as regas que você deu'), 'privacy: leaving deletes the given helps')
+ const visitas = text(PRIVACY).indexOf('No app instalado e na versão web hospedada, Visitas é opcional')
+ t.ok(visitas >= 0 && text(PRIVACY).indexOf('No app instalado e na versão web hospedada, a Varandinha') > visitas, 'privacy: after the Visitas paragraph')
+})
+
test('legal: version 73 keeps the one-time notes from repeating on another device', async (t) => {
const { TERMS, PRIVACY } = await load()
const text = (doc) => doc.sections.flatMap(({ paragraphs }) => paragraphs).join(' ')
diff --git a/apps/app/test/nav.test.js b/apps/app/test/nav.test.js
index 9833a119..3157b10a 100644
--- a/apps/app/test/nav.test.js
+++ b/apps/app/test/nav.test.js
@@ -249,7 +249,7 @@ test('grupo and comunidade are keyed by a lowercase hex64 root key', async (t) =
for (const key of [undefined, null, '', 'ceu', A.toUpperCase(), A + ':1']) t.absent(validEntry({ screen: 'fas', key }), String(key))
t.ok(validEntry({ screen: 'melhores-amigos' }))
t.absent(validEntry({ screen: 'melhores-amigos', key: A }))
- t.alike(SCREENS, ['conversa', 'membro', 'curtidas', 'citacoes', 'grupo', 'comunidade', 'comunidade-info', 'mensagem', 'seguindo', 'seguidores', 'paginas', 'novapagina', 'paginaajustes', 'comunidades', 'pedidos', 'anuncio', 'anunciar', 'editar-anuncio', 'avaliar', 'anuncios', 'depoimentos', 'momentos', 'salvos', 'assunto', 'recados', 'fas', 'melhores-amigos', 'topico', 'eventos', 'visitas'])
+ t.alike(SCREENS, ['conversa', 'membro', 'curtidas', 'citacoes', 'grupo', 'comunidade', 'comunidade-info', 'mensagem', 'seguindo', 'seguidores', 'paginas', 'novapagina', 'paginaajustes', 'comunidades', 'pedidos', 'anuncio', 'anunciar', 'editar-anuncio', 'avaliar', 'anuncios', 'depoimentos', 'momentos', 'salvos', 'assunto', 'recados', 'fas', 'melhores-amigos', 'topico', 'eventos', 'visitas', 'varandinha', 'varandinha-rua'])
t.absent(validEntry({ screen: 'cadeira', key: A }))
t.ok(SCREENS.includes('comunidade'))
for (const screen of ['grupo', 'comunidade', 'comunidade-info']) {
@@ -386,7 +386,7 @@ test('momentos is keyed by a lowercase hex64 author', async (t) => {
test('popTo drops back to an index and refuses bounds outside the stack', async (t) => {
const { EMPTY, MAX_DEPTH, SCREENS, push, pop, popTo, top } = await loadNav()
t.is(MAX_DEPTH, 20)
- t.is(SCREENS.length, 30, 'popTo adds no screen id')
+ t.is(SCREENS.length, 32, 'popTo adds no screen id')
let stack = EMPTY
for (let i = 1; i <= 4; i++) stack = push(stack, { screen: 'conversa', key: A + ':' + i })
t.is(popTo(stack, 3), stack, 'the top index is a no-op')
@@ -524,6 +524,18 @@ test('visitas takes no key', async (t) => {
t.is(top(push(EMPTY, { screen: 'visitas' })).screen, 'visitas')
})
+test('varandinha is keyed by the balcony owner hex64 and varandinha-rua takes no key', async (t) => {
+ const { EMPTY, SCREENS, push, top, validEntry } = await loadNav()
+ t.ok(SCREENS.includes('varandinha'))
+ t.ok(SCREENS.includes('varandinha-rua'))
+ t.ok(validEntry({ screen: 'varandinha', key: A }))
+ for (const key of [undefined, null, '', 'ceu', A.toUpperCase(), A + ':1', 42]) t.absent(validEntry({ screen: 'varandinha', key }), String(key))
+ t.is(push(EMPTY, { screen: 'varandinha', key: 'ceu' }), EMPTY)
+ t.ok(validEntry({ screen: 'varandinha-rua' }))
+ t.absent(validEntry({ screen: 'varandinha-rua', key: A }))
+ t.is(top(push(EMPTY, { screen: 'varandinha-rua' })).screen, 'varandinha-rua')
+})
+
test('an old key list and thread carry a valid oldPage only', async (t) => {
const { EMPTY, push, top, depth, validEntry } = await loadNav()
t.ok(validEntry({ screen: 'pedidos' }))
diff --git a/apps/app/test/tabBar.test.js b/apps/app/test/tabBar.test.js
index 5b2fc3e7..53d166fd 100644
--- a/apps/app/test/tabBar.test.js
+++ b/apps/app/test/tabBar.test.js
@@ -51,6 +51,13 @@ test('showPostButton: no "publicar" on Feira nor on its screens', async (t) => {
}
})
+test('showPostButton: no "publicar" on the Varandinha screens', async (t) => {
+ const { showPostButton } = await load()
+ for (const screen of ['varandinha', 'varandinha-rua']) {
+ for (const tab of ['rua', 'diario', 'busca']) t.absent(showPostButton({ tab, screen }), screen + ' on ' + tab)
+ }
+})
+
test('showPostButton: no "publicar" on an Assunto page', async (t) => {
const { showPostButton } = await load()
for (const tab of ['rua', 'diario', 'busca']) t.absent(showPostButton({ tab, screen: 'assunto' }), tab)
diff --git a/apps/app/test/vitrine.test.js b/apps/app/test/vitrine.test.js
index ce482135..b04dde23 100644
--- a/apps/app/test/vitrine.test.js
+++ b/apps/app/test/vitrine.test.js
@@ -1905,6 +1905,16 @@ test('garden.state answers the seeded balcony of Lia, with the helps she gave to
for (const e of records3) t.ok(f.diaryRecords.some((x) => x.author === e.author && x.record.type === 'follow' && x.record.key === f.own && x.record.on === true), 'the helper follows Lia')
})
+test('garden.state answers on the demo clock whatever options.clock says, as diary.peek does', async (t) => {
+ const { fixtures: f, request, createVitrineRequest } = await load()
+ const plain = await answer(t, request, 'garden.state', {})
+ const moved = await answer(t, createVitrineRequest(f, { clock: () => Date.parse(f.now) + 12 * 86400000 }), 'garden.state', {})
+ t.alike(moved, plain, 'the device clock moves no garden date')
+ const peek = await answer(t, request, 'diary.peek', { author: f.own, seqs: [plain.state.seq], profileSeq: 1, usernameSeq: 2 })
+ t.alike(peek.entries[0].record.pots, plain.state.pots, 'the pots match the peeked block')
+ t.is(peek.entries[0].record.at, plain.state.at)
+})
+
test('garden.play saves a valid plant act as a new state and refuses an invalid one without change', async (t) => {
const { request } = await load()
const call = (method, params) => answer(t, request, method, params)
diff --git a/apps/app/test/vitrineGuard.test.js b/apps/app/test/vitrineGuard.test.js
index e65fedef..4d22afcc 100644
--- a/apps/app/test/vitrineGuard.test.js
+++ b/apps/app/test/vitrineGuard.test.js
@@ -1,6 +1,7 @@
// The Vitrine's fixtures stand in for the node only in a development bundle
// with the opt-in env var: the provider, the account calls and the terms
-// stores, push hook and index client are the only way in, all behind vitrineEnabled.
+// stores, push hook, index client and garden clock are the only way in, all
+// behind vitrineEnabled.
'use strict'
const test = require('brittle')
@@ -12,7 +13,7 @@ const SRC = path.join(APP, 'src')
const VITRINE_DIR = path.join(SRC, 'vitrine')
// src/client/connect.web.js only reads enabled.js, so the Vitrine page skips
// the browser node script it would otherwise preload.
-const ALLOWED = ['src/node.js', 'src/account.js', 'src/termsStore.web.js', 'src/termsStore.native.js', 'src/usePush.web.js', 'src/indexClient.js', 'src/client/connect.web.js', 'src/media/fetch.js']
+const ALLOWED = ['src/node.js', 'src/account.js', 'src/termsStore.web.js', 'src/termsStore.native.js', 'src/usePush.web.js', 'src/indexClient.js', 'src/client/connect.web.js', 'src/media/fetch.js', 'src/gardenClock.js']
const TERMS_STORES = ['src/termsStore.web.js', 'src/termsStore.native.js']
const IMPORT_RE = /(?:\bfrom\s*|\brequire\s*\(\s*|\bimport\s*\(\s*)(['"])([^'"]*vitrine\/[^'"]*)\1/g
const GUARD_RE = /const VITRINE = vitrineEnabled\(\{ EXPO_PUBLIC_VARANDA_VITRINE: process\.env\.EXPO_PUBLIC_VARANDA_VITRINE \}, typeof __DEV__ !== 'undefined' && __DEV__\)/
@@ -77,7 +78,7 @@ test('vitrineEnabled needs a development bundle and the exact opt-in', async (t)
t.is(vitrineEnabled(undefined, true), false)
})
-test('only the node, account, terms stores, push hook and index client import src/vitrine', (t) => {
+test('only the node, account, terms stores, push hook, index client and garden clock import src/vitrine', (t) => {
const importers = []
for (const file of appSources()) {
const code = withoutComments(fs.readFileSync(file, 'utf8'))
diff --git a/apps/site/public/privacidade/index.html b/apps/site/public/privacidade/index.html
index 6e21285c..0a367137 100644
--- a/apps/site/public/privacidade/index.html
+++ b/apps/site/public/privacidade/index.html
@@ -7,7 +7,7 @@
Varanda: Política de Privacidade
-
+
@@ -27,8 +27,8 @@
Política de Privacidade
-
Versão 77, sujeita a revisão jurídica. Não é parecer jurídico.
-
Versão 77, de 17/11/2026. Este é o texto que o app apresenta para aceite e que fica em Ajustes, no item Termos e privacidade. O aceite é feito no app. Veja também os Termos de Uso. A visita a este site tem regras próprias, na página inicial.
+
Versão 78, sujeita a revisão jurídica. Não é parecer jurídico.
+
Versão 78, de 17/11/2026. Este é o texto que o app apresenta para aceite e que fica em Ajustes, no item Termos e privacidade. O aceite é feito no app. Veja também os Termos de Uso. A visita a este site tem regras próprias, na página inicial.
Quem trata os dados
A proposta é que a controladora seja a associação que publica o Varanda e mantém os serviços compartilhados. A definição desse papel numa rede P2P ainda depende de parecer jurídico.
@@ -59,6 +59,7 @@
Diário, perfil, fotos e vídeos
Na versão web hospedada e no app instalado, votar numa enquete é público. Numa enquete de uma publicação, o voto é um registro no seu diário, visível para qualquer pessoa que o leia; numa enquete de um tópico de grupo público, o voto é um registro no grupo, visível para os membros que o leem. Em ambos, mostra em quem ou em qual opção você votou. Retirar o voto grava um novo registro que desfaz o anterior, e os registros anteriores, com as suas datas, continuam públicos, dentro dos limites da exclusão: cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. Os totais de uma enquete de publicação são montados pelo semeador a partir desses registros públicos, mostrados com o aviso de que podem estar incompletos, e o app confere cada votante no diário dele antes de mostrá-lo em Quem votou. Quando alguém abre uma enquete ou a lista de quem votou numa opção, o app pede essas informações ao semeador; como esses pedidos vão pela conexão em que o app já se identificou com a sua conta, o semeador vê qual enquete e qual opção foram abertas e pode associar essa leitura à conta de quem abriu. O índice fica em memória no semeador e some ao reiniciar. Os totais e os votantes de uma enquete de grupo vêm do próprio grupo, sem passar pelo índice.
Na versão web hospedada e no app instalado, um evento e as respostas de presença, Vou e Talvez, são públicos. Num evento de uma publicação, o evento e a resposta são registros no diário de quem os publicou, visíveis para qualquer pessoa que o leia; num evento de um grupo público, são registros no grupo, visíveis para os membros que o leem. A resposta mostra quem respondeu e o que respondeu, e retirar a resposta grava um novo registro, e os registros anteriores, com as suas datas, continuam públicos, dentro dos limites da exclusão: cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. Quando alguém abre o perfil de uma pessoa, o app pede ao semeador a lista dos eventos dela; como esse pedido vai pela conexão em que o app já se identificou com a sua conta, o semeador vê qual perfil foi aberto e pode associar essa leitura à conta de quem abriu. Os lembretes de eventos ficam só no aparelho, no armazenamento local do navegador ou num arquivo do app, não são enviados a ninguém e não ficam no seu diário. O arquivo de calendário é gerado no próprio aparelho, na versão web.
No app instalado e na versão web hospedada, Visitas é opcional e começa desligado. Ligado, o app envia um aviso de visita, no máximo 10 por dia, quando você abre o perfil de alguém que também está com Visitas ligado, e busca os avisos que outras pessoas enviaram a você. É mútuo: você só vê quem visitou enquanto o seu interruptor está ligado e o da outra pessoa estava ligado na visita. Ligar ou desligar Visitas grava um registro público e pequeno no seu diário, só com o estado, ligado ou desligado, e a data, e por isso participar é público: qualquer pessoa que leia o seu diário pode ver que Visitas está ligado. A lista de visitantes fica só no seu aparelho, com a precisão de um dia, guardada por até 30 dias, e é apagada quando você desliga. Os avisos viajam selados por semeadores que não conseguem lê-los, num canal à parte das mensagens diretas, e nunca acordam ninguém nem geram notificação; o semeador vê um envelope cifrado sem nome de diário, como nas mensagens diretas, e a conexão pode revelar o endereço de rede. Um semeador que ainda não tem esse canal não recebe avisos, e o app não os envia por outro caminho.
+
No app instalado e na versão web hospedada, a Varandinha é opcional e começa desligada. Ligar ou desligar grava no seu diário um registro público que diz só ligado ou desligado, e por isso participar é público. O que você planta em cada vaso, as datas de plantio, rega e colheita e cada rega que você faz, com a varanda regada, a data e o vaso, também são registros públicos no seu diário, visíveis para qualquer pessoa que o leia, sem texto livre. A pessoa cuja planta você regou vê o seu nome. O estado do jogo é declarado por cada pessoa e não é conferido: a assinatura do diário prova quem gravou o registro, não que a planta cresceu pelas regras. O semeador monta, a partir desses registros públicos, apontadores para eles (a chave do diário e o número do registro e, numa rega, a varanda regada, a data e o vaso), sem guardar planta nem nome, e fica sabendo qual varanda o seu aparelho abre, como já sabe qual perfil uma conexão lê; o aparelho confere cada registro apontado antes de mostrá-lo. Não há dinheiro, compra, recompensa sorteada, ranking nem prêmio, os registros do jogo não são usados para traçar perfil nem para publicidade, e nenhuma notificação pede para alguém voltar. O app mantém só o estado mais recente da sua varanda: ao gravar um novo, marca o anterior como apagado. A cada nova rega, o app marca como apagadas até sete das suas regas com mais de cerca de três dias; as que sobrarem continuam públicas até as regas seguintes ou até você sair. Sair da Varandinha marca como apagados os seus registros do jogo, inclusive as regas que você deu, e deixa no diário o registro público de desligado; cópias que outras pessoas já buscaram podem continuar. Sair apaga só os seus próprios registros: as regas que vizinhos fizeram na sua varanda ficam no diário deles, e só quem regou pode apagá-las.
Música do Audius
Quando a associação liga a música, quem compõe uma publicação pode buscar no Audius ou colar um link dele, e quem lê pode ouvir. Numa publicação, com um trecho, uma faixa ou uma playlist, só mostrar o cartão não faz pedido ao Audius nem ao serviço de conta: o app pede a música, e depois a capa, só quando você toca no cartão. Num momento, se a associação ligar a música nos momentos, ver um momento com música, inclusive um seu, já pede o trecho de 15 segundos ao serviço de conta, sem um toque à parte; o trecho toca em seguida, a não ser que o navegador só deixe tocar som depois de um toque. Num momento aberto com o som silenciado, o app só pede o trecho quando você ativa o som. A escolha de silenciar o som fica guardada neste aparelho, num pequeno arquivo do app no Android e no iPhone e no armazenamento local do navegador (localStorage) na web, continua valendo depois de fechar e abrir o app ou recarregar a página, até você ativar o som de novo, e não é enviada a ninguém. Ela não silencia um cartão de música do Audius em que você toca nem os players de YouTube, SoundCloud, Spotify e Apple Music. Enquanto você vê os momentos, o app também pode pedir antes o trecho do momento seguinte, quando ele tem música, para que a música possa começar junto com a foto: pede a faixa e a permissão para tocá-la e, às vezes, o começo do áudio, sem tocar nada antes de o momento aparecer. Por isso o serviço fica sabendo que a sua conta pediu aquela faixa, mesmo que você não chegue a esse momento. Com o som silenciado, o app não pede nada antes. Esse pedido antecipado conta nos mesmos limites diários de uso. A capa continua sendo pedida só depois que a música daquele momento começa a tocar. O áudio não é guardado no aparelho. O app nunca carrega um quadro do Audius. Se você escolher abrir o link fora do Varanda, o site do Audius recebe diretamente o endereço de internet do seu aparelho, conforme a política dele.
O serviço vê o texto da busca, a posição da página de resultados, o link colado, o identificador da faixa ou da playlist e o áudio em trânsito. A partir do pedido de quem compõe ou de quem ouve, ele envia ao Audius o texto da busca, a posição e o tamanho da página de resultados, o identificador da faixa ou da playlist ou o link colado, a partir do endereço da associação. O Audius recebe esse endereço, nunca o endereço de internet do seu aparelho, a sua chave ou o seu token de acesso. Sua conta também não é repassada ao Audius. O áudio passa pelo serviço de conta da associação, que não guarda uma cópia.
diff --git a/apps/site/public/termos/index.html b/apps/site/public/termos/index.html
index 75195f79..bf8f6ccf 100644
--- a/apps/site/public/termos/index.html
+++ b/apps/site/public/termos/index.html
@@ -7,7 +7,7 @@
Varanda: Termos de Uso
-
+
@@ -27,8 +27,8 @@
Termos de Uso
-
Versão 77, sujeita a revisão jurídica. Não é parecer jurídico.
-
Versão 77, de 17/11/2026. Este é o texto que o app apresenta para aceite e que fica em Ajustes, no item Termos e privacidade. O aceite é feito no app. Veja também a Política de Privacidade.
+
Versão 78, sujeita a revisão jurídica. Não é parecer jurídico.
+
Versão 78, de 17/11/2026. Este é o texto que o app apresenta para aceite e que fica em Ajustes, no item Termos e privacidade. O aceite é feito no app. Veja também a Política de Privacidade.
O que é o Varanda
O Varanda é uma rede social P2P em desenvolvimento contínuo: recursos podem mudar, e o que ainda não existe aparece nestes documentos como planejado. P2P significa que os aparelhos trocam cópias dos diários entre si. Os semeadores são serviços que também guardam e distribuem essas cópias.
@@ -66,6 +66,7 @@
Seu conteúdo
Você pode criar uma enquete numa publicação do seu diário, com 2 a 4 opções, e criar tópicos, com ou sem enquete, num grupo público. Votar numa enquete é público: o voto em uma enquete do diário é um registro no seu diário, e o voto numa enquete de um grupo público é um registro no grupo, e em ambos qualquer pessoa que leia o seu diário ou o grupo pode ver em quem ou em qual opção você votou, e a pessoa que criou a enquete pode ver o seu voto. O app avisa disso antes do seu primeiro voto. Retirar o voto grava um novo registro que desfaz o anterior, e os registros anteriores, com as suas datas, continuam públicos; cópias que outras pessoas ou semeadores já buscaram podem continuar existindo. Enquetes e tópicos não têm data de encerramento. Os totais de uma enquete do diário vêm do semeador e podem estar incompletos. Em grupos privados não há tópicos nem enquetes, e não vote se não quiser que todos vejam o seu voto.
Você pode publicar um evento no seu diário, com título, início, fim opcional e lugar, e criar um evento num grupo público. Eventos são públicos: a publicação de um evento no seu diário, um evento de um grupo e as respostas de presença, Vou e Talvez, são registros que qualquer pessoa que leia o seu diário ou o grupo pode ver, com quem respondeu e o que respondeu, e a pessoa que criou o evento pode ver a sua resposta. Retirar a resposta grava um novo registro, e os registros anteriores, com as suas datas, continuam públicos. Um evento não pode ser editado: para mudá-lo ou cancelá-lo, apague a publicação ou peça a um administrador que a esconda. Em grupos privados não há eventos. O lembrete de um evento fica só no seu aparelho.
Visitas é opcional e começa desligado. Se você ligar, o app mostra os perfis que visitaram o seu e registra as suas visitas aos perfis de quem também está com Visitas ligado: a troca é mútua, você só vê quem visitou enquanto o seu interruptor está ligado e o da outra pessoa estava ligado na visita. A lista de visitantes fica só no seu aparelho, com a precisão de um dia, e é apagada quando você desliga. Desligar para de enviar e de receber visitas, mas não desfaz as que já foram enviadas. Visitas não são mensagens: não acordam ninguém e não geram aviso.
+
A Varandinha é um jogo opcional e começa desligada: cada pessoa cuida dos vasos da própria varanda, planta, rega e colhe, e as plantas crescem no relógio de quem olha. Você só rega a varanda de quem segue, uma vez por dia por varanda. Participar, o que você planta, as datas de plantio, rega e colheita e de quem é a varanda que você regou são registros públicos no seu diário, e a pessoa cuja planta você regou vê o seu nome. O jogo não tem dinheiro, compra, recompensa sorteada, ranking nem prêmio, e nenhuma notificação pede para alguém voltar. O estado de cada varanda é declarado por quem joga e não é conferido por ninguém. Sair da Varandinha marca os seus registros do jogo como apagados e deixa no seu diário um registro público de que o jogo foi desligado; cópias que outras pessoas já buscaram podem continuar. Sair apaga só os seus próprios registros: as regas que vizinhos fizeram na sua varanda ficam no diário deles, e só quem regou pode apagá-las.
Essa autorização não alcança o conteúdo cifrado das mensagens diretas e dos grupos privados, exceto o que alguém enviar numa denúncia. Ela termina quando você apaga o conteúdo ou exclui a conta, respeitados os Limites da exclusão e o que a associação precisa guardar para moderação e pedidos legais.
Convivência e denúncias
O Varanda não tolera conteúdo censurável nem abuso contra outras pessoas. É proibido publicar ou enviar: conteúdo ilegal; exploração ou sexualização de crianças e adolescentes; imagens íntimas de alguém sem o consentimento dessa pessoa; pornografia; ameaças, assédio ou intimidação; discurso de ódio; incentivo à violência ou à automutilação; e spam. Quem descumprir essa regra pode ter a conta bloqueada pela moderação, como descrito em Como funciona a moderação. O app e a versão web recusam, no próprio aparelho e antes de publicar ou enviar, publicações, momentos, mensagens de grupo público, nomes, bios e @nomes de pessoas e de páginas, anúncios e avaliações da Feira, cartões de convite, nomes de grupo público ou de comunidade e depoimentos (também ao mostrar no perfil um depoimento recebido) que contêm termos de uma lista curta e pública; nada dessa conferência sai do aparelho nem fica registrado, e mensagens diretas e grupos privados não passam por ela. O serviço de conta aplica a mesma lista a um @nome novo, de pessoa ou de página, e ao que uma página publica por ele (publicações, respostas, citações, perfil, anúncios e mensagens em grupo público): recusa o pedido e não guarda o @nome nem o texto recusado. Um @nome que você já tem não é conferido de novo.
diff --git a/apps/site/test/legal.test.js b/apps/site/test/legal.test.js
index 5e2908c6..f85e7d09 100644
--- a/apps/site/test/legal.test.js
+++ b/apps/site/test/legal.test.js
@@ -49,7 +49,7 @@ test('legal pages: the files on disk are the render of apps/app/src/legal.js', a
// rewrites text fails here even when the files match its output.
test('legal pages: title, version, review note and every section of legal.js, in order', async (t) => {
const legal = await loadLegal()
- t.is(legal.LEGAL_VERSION, 77)
+ t.is(legal.LEGAL_VERSION, 78)
t.is(legal.LEGAL_DATE, '17/11/2026')
for (const page of PAGES) {
const doc = legal[page.doc]
diff --git a/docs/app.md b/docs/app.md
index 85a5bb3f..aee0c850 100644
--- a/docs/app.md
+++ b/docs/app.md
@@ -263,6 +263,7 @@ A barra de baixo mostra só ícones, sem palavras (os leitores de tela continuam
- **Fóruns e enquetes.** Só onde o nó é hospedado (web hospedada e app instalado); no app com configuração manual e no `varanda-serve` o nó não escreve nem lê esses registros (`choice.set`, `group.choose`, `group.topics` e as opções `topic`, `poll` e `marks` respondem "leitura sob demanda só na versão web"). **Enquete do diário:** em Publicar há a opção **Enquete** (`PollEditor`: pergunta mais 2 a 4 opções de até 60 caracteres, as mensagens "Coloque pelo menos duas opções.", "No máximo quatro opções.", "Preencha ou remova as opções vazias.", "Cada opção tem no máximo 60 caracteres." e "As opções precisam ser diferentes."); a publicação mostra o `PollCard` com as opções, os votos e a escolha da pessoa. Antes do primeiro voto o app diz "Seu voto é público: quem vê o seu diário pode ver em quem você votou.". Os totais vêm do semeador e levam o aviso "Os totais vêm do semeador e podem estar incompletos." (ou "Ainda não deu para ler os totais."); "Quem votou" lista os votantes de cada opção, conferidos no diário de cada um. Votar de novo troca a escolha e tocar na escolhida a retira. **Grupos públicos:** o grupo tem o segmento **Tópicos** ao lado da conversa (a lista de tópicos, do mais novo para o mais antigo, com o número de respostas e a última resposta), o botão de novo tópico (`NewTopicSheet`, um campo "Assunto" cuja primeira linha é o título, e "Adicionar enquete") e a tela `Topico`, com o tópico, a enquete e as respostas; a conversa continua mostrando os tópicos como mensagens comuns. Um grupo privado não tem o segmento nem a opção. Ordem de lançamento: semeadores, depois a web hospedada, depois os apps; a conferência manual está em `docs/verification/feat-foruns-enquetes.md`, e as telas na lista de `docs/design-review.md`.
- **Eventos.** Só onde o nó é hospedado (web hospedada e app instalado); no app com configuração manual e no `varanda-serve`, `group.events` e a opção `event` respondem "leitura sob demanda só na versão web" e a tela não oferece evento. Publicar ganha a opção Evento (título, início, fim opcional, lugar); em grupos públicos o evento é um registro lateral `group-event` numa mensagem raiz, e a resposta Vou ou Talvez reaproveita os votos das enquetes (a resposta é pública). Um evento não se edita: apague, ou um admin esconde. O perfil de outra pessoa ganha uma linha Eventos (e o Diário próprio um botão Eventos), que abre a tela Eventos (lida de `/index/events/`, com o aviso de totais incompletos) e a comunidade uma linha Agenda (`group.events` de cada grupo, só os 12 primeiros grupos públicos e a primeira página de cada um, com o aviso de lista incompleta quando algo fica de fora). O lembrete é um registro local de referência e início, guardado só no aparelho, e uma faixa no app aberto nas 24 horas antes; não há notificação do sistema (pendência anotada, sem nova dependência). Adicionar ao calendário (`.ics`) só na web, porque o compartilhamento nativo não anexa arquivo.
- **Visitas.** Só onde o nó é hospedado (web hospedada e app instalado); no `varanda-serve` e no app com configuração manual a tela não oferece Visitas. Opcional e desligado por padrão: a folha de consentimento abre com o interruptor desligado, e ligar grava um registro público `visits` (`on`, `at`). A troca é mútua e a lista de visitantes (agrupada por dia, com precisão de um dia, só no aparelho) é apagada ao desligar. Os avisos (`visits.note`, no máximo 10 por dia) viajam selados pela pista silenciosa `varanda/visit/1`, um repositório de semeador à parte das mensagens diretas, sem acordar ninguém (não há push por aviso); um semeador sem a pista não recebe avisos e o nó não usa o repositório das mensagens diretas. Métodos `visits.set`, `visits.state`, `visits.list`, `visits.clear`.
+- **Varandinha.** Só onde o nó é hospedado (web hospedada e app instalado); no `varanda-serve` e no app com configuração manual a tela não oferece o jogo. Opcional e desligado por padrão. Um jogo de varanda: a pessoa planta, rega e colhe nos vasos da própria varanda, no relógio de quem olha, e rega uma vez por dia a varanda de quem segue. Todo o estado são registros assinados (`garden`, `garden-state`, `garden-help`) no diário de quem joga; o semeador guarda só apontadores e o nó do navegador confere cada bloco. Quem recebe a rega vê o nome em "Quem regou". Sair marca os registros do jogo como apagados. Entra por Ajustes (abaixo de Visitas), pelo Diário e pelo perfil de um membro, este só depois de uma consulta ao apontador da varanda no semeador. Duas telas: a Varandinha e Varandas da rua. Métodos `garden.set`, `garden.state`, `garden.play`, `garden.help`; rotas do semeador `/index/garden/` e `/index/garden//rua`. Não há push nem aviso que chame a pessoa de volta.
- **Linha de publicação.** O avatar e o nome abrem o perfil do autor (Membro; o próprio nome abre a aba Diário), com alvos de toque perto de 44 pt no nativo (a linha "republicou" sem "seguir" chega a cerca de 36 pt, o nome sob "republicou" a cerca de 32 pt, e a web ignora `hitSlop`); o chip "Respondendo a Nome" (alvo de 44 pt) abre a publicação respondida (texto simples onde a tela não dá abertura); tocar no texto, no tempo ou no espaço vazio abre a Conversa (as fotos guardam o toque delas); na web hospedada, um `@nome` no texto (também no cartão da citação) é um link: tocar, ou Enter e espaço pelo teclado, abre o perfil sem abrir a Conversa; o nome do próprio autor da linha abre sem pedido, e qualquer outro é resolvido pelo serviço de conta (só o dono atual do @nome, com "Sem conexão para abrir o @nome.", o aviso de nome não encontrado ou "Não foi possível abrir o @nome agora." nas falhas); no app com configuração manual e com o `varanda-serve` o `@nome` segue sem link, mas os links abaixo funcionam; "Nome republicou" abre o perfil de quem republicou; o cartão da citação abre a publicação citada (só um nível: uma citada que também cita mostra "cita outra publicação"). Uma legenda longa fica recolhida: 3 linhas quando a publicação tem fotos e 9 quando é só texto. O recolhimento só começa quando a estimativa passa do limite por 2 linhas ou mais, então uma legenda uma ou duas linhas acima fica aberta. Embaixo da legenda recolhida há um botão "mais" (com fotos) ou "ver mais" (só texto), de cerca de 44 pt de altura, com 12 pt de espaço próprio acima dele (não cobre a última linha); aberta, o botão diz "menos". O botão abre e fecha no lugar, sem abrir a Conversa, e o carrossel continua na mesma foto. Leitores de tela leem a legenda inteira pelo rótulo da publicação e ouvem o botão como "mais, ver texto completo", "ver mais, texto completo" ou "menos, recolher texto", com o estado aberto ou fechado. Enquanto recolhida, a legenda é texto simples: links e @menções só funcionam depois de aberta (o recolhimento poderia esconder parte de um endereço). No app nativo, a legenda mede as linhas reais depois do desenho e, se couber, aparece inteira sem botão; a web não mede e decide só pela estimativa pela largura, então uma legenda de exatamente 3 ou 9 linhas pode manter o botão até ser aberta uma vez. Um link `http://`, `https://` ou `www.` no texto da publicação, da bio do Diário ou do Membro, na mensagem de grupo e na mensagem privada fica sublinhado na cor de destaque e abre direto, sem confirmação: no navegador do aparelho, ou em nova aba na web (um `www.` abre como `https://`). Tocar no link nunca abre a Conversa. No cartão da citação o link segue como texto, porque o cartão corta o texto em 6 linhas e o corte poderia esconder parte do endereço; tocar no cartão abre a publicação citada, onde o link funciona. Só `http` e `https` viram link; um domínio sem prefixo (como `exemplo.com.br`) segue como texto, e um host com caractere fora do ASCII não vira link. Um `@nome` dentro de um link não é link de perfil (a notificação de menção não muda), e o `@nome` fora de link segue como acima. O texto pendente na fila de saída e as prévias do campo de escrita não têm link. Embaixo, uma barra horizontal com responder, republicar, curtir (coração cheio quando curtido; "descurtir") e "mais" (⋯), cada uma com o número só quando ele é conhecido e maior que zero (na web hospedada, vindo do índice), em forma compacta ("12,3 mil"); o número completo só é lido por leitor de tela nos botões que abrem quem curtiu e quem republicou. No topo da publicação, ao lado do nome, ficam "seguir" (só na Espiadinha, botão de texto em destaque) e o ⋯ ("mais ações"), com alvos de 44 pt centrados na linha do nome; uma publicação só com o ⋯ não fica mais alta que o texto. A data vem depois do nome, compacta, e a partir de 7 dias como data ("5 nov", ou "5 nov 2025" em outro ano); o leitor de tela ouve a data por extenso ("3 h", "ontem", "5 nov"). Para leitor de tela, "seguir" e o ⋯ vêm depois da legenda, do "Ver mais" e da prévia das respostas, e antes da barra de ações. Segurar 350 ms no corpo, na legenda, no nome, no @nome, na data ou na linha "respondendo a" abre a mesma folha de ações (desligado com leitor de tela ligado). A barra não tem lápis, bandeira nem lixeira. Republicar abre a folha "Republicar" (ou "Desfazer republicação", quando a publicação já foi republicada) e "Citar"; sem rede, a folha traz só "Citar". "Mais" abre "Copiar link" (quando a publicação tem link), "Denunciar" (publicações de outros, com a conta conectada) e "Apagar" (publicações próprias, em vermelho, com a confirmação de sempre). Uma publicação de diário tem o link `/p//` sempre que o app conhece a origem (a da instalação ou, na web, a do endereço aberto); com ele aparecem o botão "compartilhar" na barra e "Copiar link" no "mais". O link mostra a publicação só quando o autor a publicou na web (veja "Página pública na web"); nos outros casos leva ao app. Mensagens privadas, grupos e momentos não têm link, nem a publicação de uma Página quando o app sabe que é uma Página. Enquanto o perfil do autor não chegou, e sempre na Busca, uma publicação de Página também recebe o link, que então só leva ao app, porque o semeador não mostra páginas de Página. Curtir e republicar mudam na hora (otimista) e voltam atrás com a mensagem de erro se `like.set` / `repost.set` falha; o botão fica desligado enquanto o pedido roda. Curtir e republicar funcionam também no app com configuração manual e no `varanda-serve`, sem contagens. Na web hospedada, o número de curtidas e o número de republicações, quando aparecem, são controles separados que abrem a lista de quem curtiu e de quem republicou; o coração liga e desliga, e o ícone de republicar abre a folha (leitura de tela: "republicar ou citar"); o número de respostas não abre lista. O número de citações não aparece na barra, porque "Citar" fica na folha de Republicar; somá-lo às republicações faria o número não bater com a lista de quem republicou. Uma linha de republicação abre a lista da publicação original. Em A Rua, um comentário entra no cartão da publicação a que pertence: em cima, "Ana comentou" ("Ana e Bia comentaram", "Ana e mais 2 comentaram"; numa republicação fica "Nome republicou"); embaixo da barra de ações, até 2 linhas de comentário de uma linha ("Nome: texto"; comentário só com foto não ocupa linha) e "Ver todos os N comentários" (ou "Ver comentários"), sem rótulo visível, num botão só que abre a Conversa no comentário mais novo; o leitor de tela ouve "Comentários." antes das linhas. O ícone de responder de uma linha da A Rua (e do Diário e das outras listas) abre a Conversa daquela publicação com a barra em foco, quando o nó está cheio e a pessoa não age como Página; senão abre a Publicar.
- **Página pública na web.** Nas publicações próprias, o menu "mais" da linha de publicação ganha "Página pública na web" só com o nó hospedado (a web hospedada e o app instalado com a instalação) e só enquanto a instalação responde que a página pública está ligada (`GET /p/policy`, chave `VARANDA_POSTS_ORIGIN` do semeador, [protocol.md](protocol.md) seção 16); sem isso, ou na dúvida, a linha não aparece. Uma resposta definitiva fica guardada durante a sessão; falha de rede, erro do servidor, 408 ou 429 fazem a pergunta de novo quando o app volta a ficar online ou visível. A linha abre a folha "Página pública na web", que lê se a publicação está publicada (`post.shared`), pede o aceite antes de publicar ("Publicar na web", `post.share`) e permite tirar da web ("Tirar da web", `post.unshare`), RPC 5.121 a 5.123 em [rpc.md](rpc.md). Depois de escrever, a folha diz só que o pedido foi enviado, porque o nó informa o que este aparelho escreveu, e não que o semeador já tem. Publicar nunca abre o compartilhamento: "Compartilhar" e "Copiar link" agem só no próprio toque, com o link `/p//`. Quando o semeador não mostra a publicação, o link leva a `/publicacao//` no app, que guarda a publicação como destino (na web, na aba, por até 1 hora, e o caminho sai da barra de endereço; no app nativo, só na memória do processo). Sem sessão, Entrar mostra o cartão "Você abriu o link de uma publicação. Entre ou crie sua conta para ver.", depois de um convite ou de um link de grupo ou comunidade, se houver; "Agora não" esquece o destino, e o cartão não dá código de entrada. Para quem não tem conta no aparelho ou no navegador, numa primeira visita (antes dos cartões de apresentação) ou numa seguinte, um cartão diz que há uma publicação esperando, com Entrar (Termos, depois Entrar com o cartão da publicação), Como funciona (os cartões de apresentação e a volta) e Agora não (segue para a apresentação numa primeira visita, ou para Termos e Entrar nas demais, e o destino fica). Com a sessão aberta, as abas na tela e o nó hospedado, a Conversa da publicação abre uma vez e o destino é apagado. Termos e Política na versão 48. Em Publicar, a caixa "Publicar também na web" aparece nas mesmas condições da linha "Página pública na web" do menu "mais" (nó hospedado, com a política `/p/policy` ligada), e só com rede, numa publicação comum no próprio diário. Não aparece numa resposta, citação, enquete, evento, Momento nem ao publicar como uma Página; essas continuam podendo ir para a web depois, pelo "mais" da publicação. A caixa começa desmarcada toda vez que a folha abre e volta a desmarcar sempre que deixa de ser oferecida; marcada, mostra o mesmo texto de consentimento da folha. Depois que a publicação sai, o app envia um `post.share` e abre a folha "Página pública na web" dela: com o aviso "Enviado para a web..." e o link, "Compartilhar" e "Copiar link" se deu certo; se o envio falhar, a folha diz que a publicação saiu mas não foi para a web (com o motivo, quando há) e oferece "Publicar na web"; se não deu para confirmar, a folha diz o que este aparelho registrou (enviado, ou que não foi para a web) e, quando nem isso dá para ler, que o envio à web não foi confirmado, pedindo para abrir de novo. Se o nó não devolve a posição da publicação, um aviso curto diz que ela saiu mas não foi para a web e aponta o menu da publicação. Nada é reenviado automaticamente. Com a caixa marcada a publicação nunca vai para a fila de saída: se o portão de escrita não alcança o semeador, o rascunho fica em Publicar com o erro. Termos e Política seguem na versão 64, porque a seção "Página pública de uma publicação" já descreve uma escolha por publicação que pode ser retirada.
- **Música em publicações.** Numa publicação (A Rua, Diário, perfil, conversa, Busca, Espiadinha), um cartão de YouTube, SoundCloud, Spotify ou Apple Music mostra o player do próprio provedor sem toque: não há botão para carregar nem para fechar o player, nem aviso embaixo do cartão. O quadro é montado depois que o cartão fica dentro da faixa da lista (pelo menos metade da largura e o menor entre metade da altura e 120 pt, abaixo da barra de cima e acima da barra de abas, quando a tela tem uma) ou perto dela, a até duas alturas da faixa para cima ou para baixo (`EMBED_AHEAD_BANDS` = 2), em duas conferências seguidas com 500 ms de intervalo (`EMBED_TICK_MS` = 500, `EMBED_DWELL_TICKS` = 2), de modo que o player costuma estar carregado quando a pessoa chega ao cartão, sem prometer que sempre estará. Isso vale só na tela que a pessoa está olhando (a aba escolhida, sem nada empilhado por cima, ou a tela do topo da pilha), sem compositor, Ajustes, denúncia, ajuda, aviso de página ou bloqueio por cima, com o app em primeiro plano e sem foto em tela cheia aberta; em nenhuma outra tela um quadro começa a carregar. Na conversa de uma publicação (Conversa), a faixa termina no topo da barra de resposta. O cartão guardado continua no lugar até a página do provedor carregar (o evento de carga do documento do invólucro mais 500 ms, uma heurística: o app não vê se o provedor já desenhou o player), e um quadro que ainda não carregou, ou que está numa tela que não é a olhada ou sob uma folha, um menu ou a foto em tela cheia, não abre nada. Um quadro carregado em que a pessoa não tocou continua o mesmo enquanto a pessoa rola a mesma tela a qualquer distância, inclusive depois que a lista desmonta a linha, e voltar com a rolagem mostra a mesma página, no ponto da faixa em que ela está, sem recarregar o provedor. Um quadro que a pessoa não tocou também continua carregado quando a tela deixa de ser a olhada (troca de aba, tela empilhada por cima, folha, menu ou foto em tela cheia), ficando fora da vista e como o mais distante a ceder o lugar. "Tocado" é o quadro em que a pessoa encostou o dedo ou o foco entrou, ou qualquer quadro enquanto um leitor de tela está ligado ou ainda não respondeu, lido na hora de cada decisão. Um quadro tocado pode estar tocando, então fecha ao sair da tela olhada, ao ser coberto e quando outro áudio do Varanda começa depois do toque (cartão do Audius, mensagem de voz); um áudio que já tinha começado antes do toque não o fecha, e um não tocado não fecha por isso. Um quadro tocado também fecha quando seu cartão fica fora da faixa visível em duas conferências seguidas e novas (`embedLeaves`), com 2 s de espera depois do toque (`OPEN_GRACE_MS`), ou quando a lista desmontou sua linha, na próxima conferência de 500 ms da camada (`EmbedLayer.js`); uma linha que continua montada tem a espera de volta de cerca de 1 s descrita adiante, e na tela cheia nativa o quadro tocado continua. O toque só de leitor de tela fecha apenas um quadro que já esteve na faixa. Não há canal para dentro do quadro, então ele descarrega em vez de pausar, e o cartão guardado volta. Fora da tela cheia, quando a tela gira ou a janela muda de retrato para paisagem ou o contrário (web, PWA, iPad, Android de tela grande), um player tocado mantém o comportamento anterior: fica até outro player começar, um bloqueio ou uma troca de tela. Bloquear o app ou mandá-lo para segundo plano fecha todos, e depois eles podem voltar, em silêncio. O som de um quadro tocado pode continuar enquanto ele está carregado, embora o provedor possa pausá-lo por conta própria quando o quadro fica escondido. Nas listas de `RefreshableList.js` (A Rua, conversas, respostas de Conversa e outras), `EmbedLayer.js` desenha os quadros carregados numa única camada, o último filho do conteúdo de rolagem da própria lista, via `renderScrollComponent` do FlatList. A camada rola nativamente com a lista. A linha guarda um espaço vazio do tamanho do player, e a camada posiciona o quadro sobre ele, medido em relação ao contêiner do conteúdo de rolagem. A janela de linhas do FlatList e o corte de subviews fora da tela no Android não recarregam o quadro. Quando a lista desmonta a linha, o quadro continua carregado com opacidade 0, sem toques, escondido dos leitores de tela e, na web, fora da ordem de Tab. Quando a linha volta, o cartão retoma o mesmo quadro. Os cartões do cabeçalho de Conversa e a prévia do compositor ficam no próprio espaço, sem passar pela camada. A lista não desmonta seu cabeçalho. Eles seguem as mesmas regras, sem limite de distância. No máximo 4 quadros de provedor ficam carregados no app (`EMBED_LIVE_MAX`), incluindo a prévia do compositor; cada morte de um processo de conteúdo baixa esse teto em 1, no máximo uma vez a cada 5 s (`EMBED_SHRINK_MS`) e nunca abaixo de 2 (`EMBED_LIVE_MIN`), até o app reabrir. Um cartão que precisa de lugar marca o pedido para o quadro não tocado mais distante da faixa. Um cartão visível pode pedir a qualquer quadro não tocado, e a um tocado só quando não há nenhum não tocado parado; um cartão que só vai carregar adiante (pré-carga) pede só a um quadro não tocado pelo menos 400 pt mais longe da faixa que ele (`EMBED_YIELD_GAP`) e toma no máximo um lugar novo a cada 500 ms, para uma rolagem rápida não carregar vários de uma vez. Enquanto um cartão visível espera lugar, nenhuma pré-carga toma o lugar que ficar livre, por até 1 s depois do último pedido dele. O quadro marcado cede na própria conferência seguinte, em até 500 ms, só se continuar fora da faixa em duas conferências seguidas: uma medição que não responde conta como fora da vista, e uma resposta atrasada não custa o lugar a um quadro tocado. Uma linha desmontada conta como fora da vista, e a camada solta seu quadro na próxima conferência após o pedido. O pedido é retirado quando outro quadro sai ou quando o cartão que esperava deixa de esperar. Um quadro tocado nunca fecha para dar lugar a uma pré-carga. Se não há lugar, o cartão espera mostrando o cartão guardado. A linha sair dos dados da lista (publicação apagada, silenciada ou lista reiniciada) também fecha o quadro; inserir linhas no início não fecha nenhum. A exceção é a lista que lê de novo só a primeira página (a aba que volta, atualizar) e corta por um momento as linhas mais antigas: o quadro não tocado de uma linha cortada depois do novo fim fica carregado, fora da vista, por até 5 s (`EMBED_CUT_MS`) e volta para o cartão se a linha voltar nesse tempo; se não voltar, fecha. A lista não distingue esse corte de uma publicação apagada ou silenciada no fim do que já carregou, então o quadro não tocado dela fecha em até 5 s. Um quadro tocado fecha na hora, e quando a lista troca todos os dados por outros (uma busca nova), todos fecham na hora. Se o processo de conteúdo morre (`onContentProcessDidTerminate` no iOS, `onRenderProcessGone` no Android), o cartão guardado volta, o teto baixa em 1 como descrito acima e o player carrega de novo após a espera normal quando o cartão está dentro ou perto da faixa. Se um cartão sai de uma linha que continua montada e nos dados da lista, como uma mensagem apagada que permanece sinalizada na conversa, a lista fecha seu quadro escondido após cerca de 1 s (duas conferências de 500 ms). Uma mensagem ocultada ou apagada enquanto sua linha está fora da janela da lista fecha o player na hora. Esse intervalo permite que um cartão que some e volta na mesma linha, como uma citação que mostra "carregando" por um momento, retome o quadro. Na web, um player fora da vista cuja linha continua montada permanece alcançável com Tab. Leitores de tela e teclado alcançam um player visível depois das linhas da lista, em vez de dentro da publicação. Os endereços dos players não pedem reprodução automática (YouTube sem autoplay, SoundCloud com auto_play=false), a permissão do quadro não inclui autoplay e o WebView nativo exige um toque para tocar mídia, então nada soa antes de a pessoa apertar o play dentro do player. Músicas completas dependem do provedor. O sandbox tem allow-popups (allow-scripts allow-same-origin allow-presentation allow-popups: sem navegar a janela de cima, sem formulários e sem downloads, e sem allow-popups-to-escape-sandbox). No app nativo, um toque num link dentro do player não carrega nada no WebView: o endereço só sai para o sistema quando é https num domínio do mesmo provedor ou num subdomínio dele, e nunca pela página de redirecionamento do YouTube (`/redirect`), que leva para fora dele. Na web e no PWA, o link abre outra aba, que continua no sandbox e não consegue trocar a aba do Varanda. O player do SoundCloud não mostra os botões de comprar, compartilhar e baixar (buying=false, sharing=false e download=false no endereço), porque o link de compra é quem envia a faixa que escolhe e, na web, abriria numa aba que o app não confere. Não há o link "Abrir no ": enquanto o player não está carregado, um toque no cartão guardado abre a página guardada. Um cartão mais estreito que o mínimo do provedor (YouTube abaixo de 200 pt) nunca monta quadro e mostra o cartão guardado, que abre a página num toque. Carregar um quadro não conta como tocar, então não para uma mensagem de voz, um cartão do Audius nem um momento; o app não vê o play dentro do quadro, então apertar o play num player não pausa outro áudio. O texto mostrado da publicação esconde só o link que é o próprio item do cartão (mesma página reconstruída por `embedOf`; youtu.be/ID e watch?v=ID são o mesmo item, outro t= é outro item); todo o resto do texto fica, e o registro guardado não muda. Depois de esconder o link, a pontuação em volta se ajeita, sem que o texto mostrado ganhe link, menção ou palavra que o texto guardado não tem: um par de parênteses ou colchetes que ficou vazio só some quando há espaço ou o limite da linha do lado de fora, a pontuação só se junta à palavra anterior quando vem seguida de espaço ou do fim do texto, e se a arrumação ainda mudasse os links ou as menções, o texto original aparece ("Olha , que legal" vira "Olha, que legal", enquanto "pala( )vra" fica "pala( )vra"). Um tempo do YouTube como `t=1m30s` também é aceito. Uma medição que não responde antes da conferência seguinte conta como cartão escondido, e uma só dessas não deixa um quadro carregado ceder o lugar. Os mesmos players (nunca o do Audius) carregam também numa publicação citada (QuoteCard, onde o player fica fora da área de toque da citação e fora do invólucro de acessibilidade escondido: o nome e o horário da citação são o link que abre a publicação citada, e o player é alcançado por VoiceOver, TalkBack e teclado), nas conversas privadas e nos grupos (Bubble, em Mensagem e Grupo, onde a faixa da lista termina no topo do compositor) e na prévia do link no compositor (LinkDraftCard: Publicar, conversas privadas e grupos) assim que a prévia fica pronta, antes do envio. Na prévia do compositor, um player mais alto que um terço da janela (álbuns, playlists, sets do SoundCloud) dá lugar ao cartão guardado, e o botão de remover a prévia aparece em todos os estados. Uma folha aberta descarrega os players tocados que ficam embaixo dela e mantém os não tocados, enquanto um cartão dentro da folha mantém o seu; bloquear o app ou mandá-lo para segundo plano descarrega todos. Nos balões e nas citações, o texto mostrado esconde o link do próprio cartão do mesmo jeito (numa mensagem com formatação, o texto fica inteiro); copiar, encaminhar e responder usam o texto inteiro. Numa conversa privada ou num grupo, isso conta ao provedor que o aparelho mostrou aquele item, e quando, mas nunca o texto das mensagens. Cartões de link comuns (qualquer outro site) mostram a prévia guardada. Se a página não puder ser lida ao compor a publicação, um link de música reconhecido ainda pode ganhar cartão com o nome do provedor e sem imagem. Um link de Audius nunca carrega o player do provedor; nada do Audius toca sozinho numa publicação: o único jeito é o cartão por toque (`MusicPlayerCard.js`), descrito abaixo. Sem leitor de tela ligado, outro áudio do Varanda não zera mais a espera de um cartão que ainda não está carregado. Limites: na primeira vez que a tela é vista, na volta do bloqueio ou do segundo plano, numa rolagem rápida e quando um cartão mais próximo toma o lugar, o cartão guardado aparece até o player carregar. Na web, ao voltar para uma aba depois de trocar no fim de uma lista longa, a rolagem pode voltar mais acima (o navegador limita a posição enquanto a lista está escondida e mais curta), e players não tocados podem trocar de lugar e carregar de novo. Termos e Política na versão 53, com novo aceite. Conferência: [verification.md](verification.md), seções 186, 203, 204, 205, 207, 215, 233 e 246.
diff --git a/docs/changelog/feat-varandinha-app.md b/docs/changelog/feat-varandinha-app.md
new file mode 100644
index 00000000..1316cb8b
--- /dev/null
+++ b/docs/changelog/feat-varandinha-app.md
@@ -0,0 +1,4 @@
+### Adicionado
+
+- Varandinha e Varandas da rua no app (PR `feat/varandinha-app`): um jogo de varanda opcional, desligado por padrão e só onde o nó é hospedado (web hospedada e app instalado). A pessoa planta, rega e colhe nos vasos da própria varanda, no relógio de quem olha, e rega uma vez por dia a varanda de quem segue; a segunda rega no mesmo dia é recusada e o dono vê o nome em "Quem regou". Varandas da rua lista as varandas abertas de quem a pessoa segue. A entrada fica em Ajustes (abaixo de Visitas), no Diário e no perfil de um membro. Não há push, ranking nem prêmio. Os métodos são `garden.set`, `garden.state`, `garden.play` e `garden.help`. Ordem de lançamento: semeadores antes da web hospedada e dos apps. Conferência em `docs/verification/feat-varandinha-app.md`.
+- Termos e privacidade versão 78: dizem que a Varandinha é opcional e desligada por padrão, que os dados do jogo (`garden`, `garden-state`, `garden-help`) são públicos no diário de quem joga, que o semeador guarda só apontadores e que sair marca como apagados os registros do jogo. Quem já aceitou antes precisa aceitar de novo.
diff --git a/docs/design-review.md b/docs/design-review.md
index 5798c9c5..8713afba 100644
--- a/docs/design-review.md
+++ b/docs/design-review.md
@@ -78,6 +78,7 @@ Confira cada tela nas plataformas do ciclo:
- Faixa de lembrete: aparece nas 24 horas antes do início, com o título, "começa em N min" ou "começa em N horas" e o botão de dispensar; sem notificação do sistema, e o texto avisa que o lembrete só vale com o app aberto.
- Agenda (comunidade): os eventos dos grupos públicos da comunidade, por data, com o estado vazio; grupo privado sem a opção de evento.
- Visitas, só no nó hospedado (Ajustes › Visitas: interruptor, folha de consentimento que abre desligada, lista de visitantes agrupada por dia, estado vazio, aviso de mensagens privadas desativadas ao ligar e aviso de limite diário). Claro e escuro, 375x812 e 1280x800, com texto grande, alvos de 44 pt, sem emoji decorativo; sem contagem de visualizações.
+- Varandinha, só no nó hospedado (entrada em Ajustes abaixo de Visitas, no Diário e no perfil de um membro; tela da varanda com vasos, plantar, regar e colher; Varandas da rua; lista "Quem regou", com nomes só na própria varanda; na varanda de outra pessoa, só a contagem de vizinhos que regaram; estado vazio e estado desligado; Regar some depois da rega do dia, e o nó recusa uma segunda). Claro e escuro, 375x812 e 1280x800, com texto grande, movimento reduzido, alvos de 44 pt, sem emoji decorativo; sem ranking, pontuação nem prêmio.
## Critério de revisão
diff --git a/docs/design.md b/docs/design.md
index 74e12e3c..5da4485d 100644
--- a/docs/design.md
+++ b/docs/design.md
@@ -383,6 +383,8 @@ A faixa de comunidades do perfil não cria tratamento novo: no seu Diário ela m
**Visitas (hipótese de desenho).** Ver quem visitou o perfil é opcional e começa desligado. É um acordo dos dois lados: um aparelho só envia e só recebe visitas enquanto a própria chave de Visitas estiver ligada, e só envia para quem também a ligou (um registro `visits` público no diário, que diz só ligado ou desligado). A lista de visitantes fica só no aparelho de quem a recebe, nunca no diário nem no servidor, com precisão de dia (sem hora), até 50 pessoas, uma linha por pessoa e por no máximo 30 dias, e é apagada ao desligar. O aviso viaja num canal anônimo próprio, sem acordar ninguém. Limites: um cliente modificado pode receber sem enviar, o semeador já vê qual perfil uma conexão lê, e o horário pode ligar uma leitura de perfil a um aviso que chega pouco depois (detalhes em `docs/protocol.md`, seção 11).
+**Varandinha (hipótese de desenho).** Um jogo de varanda opcional, que começa desligado: cada pessoa planta, rega e colhe nos vasos da própria varanda, no relógio de quem olha, e rega uma vez por dia a varanda de quem segue. A finalidade é só o passatempo e a convivência entre vizinhos. Dados públicos criados: o registro `garden` (participar, só ligado ou desligado), o `garden-state` (as plantas e as datas de plantio, rega e colheita) e cada `garden-help` (de quem é a varanda regada, a data e o vaso), todos no diário de quem joga e sem texto livre; quem recebe a rega vê o nome de quem regou. O semeador guarda só apontadores (chave do diário, número do registro e, numa rega, destinatário, data e vaso), nunca planta nem nome, vê qual varanda uma conexão abre, e o nó do navegador confere cada bloco. Minimização: vale só o estado mais recente (gravar um novo marca o anterior como apagado), a cada nova rega o aparelho marca como apagadas até sete das próprias regas com mais de cerca de 72 h (as que sobram ficam públicas até as regas seguintes), e sair marca como apagados os registros do jogo de quem sai, inclusive as regas que deu, deixando só o registro público de desligado; as regas que vizinhos deram ficam nos diários deles, e cópias já obtidas por outros aparelhos não são recolhidas. O estado é autodeclarado e não é conferido, por isso nada o ordena nem o premia: não há perfilamento, dinheiro, compra, publicidade, recompensa sorteada, ranking, prêmio nem notificação que chame a pessoa de volta. Quem tem 16 ou 17 anos joga com as mesmas regras de quem tem 18 ou mais (veja "Fora do escopo do MVP" e "Fases 2 e 3: adolescentes"), e a ausência de recompensa sorteada vale para todas as idades. Em aberto: o RIPD ("Antes do lançamento") precisa cobrir a Varandinha. Detalhes em `docs/protocol.md`, seção 2 "Varandinha" e seção 5 "Seeder Varandinha index".
+
**Direitos dos titulares (Art. 18) numa rede P2P**
- **Acesso e portabilidade:** o diário já está no celular da pessoa; o app exporta tudo num arquivo.
diff --git a/docs/verification/feat-varandinha-app.md b/docs/verification/feat-varandinha-app.md
new file mode 100644
index 00000000..960278fa
--- /dev/null
+++ b/docs/verification/feat-varandinha-app.md
@@ -0,0 +1,86 @@
+# Varandinha no app (PR feat/varandinha-app)
+
+Este arquivo confere as telas Varandinha e Varandas da rua, onde o nó é hospedado (web hospedada e app instalado). Use duas contas, A e B, em aparelhos ou navegadores diferentes; B segue A. Só as caixas marcadas foram executadas. Comece pelo Android, depois o iPhone e a web.
+
+## Testes
+
+- [x] `npm test -w apps/app -- test/nav.test.js test/tabBar.test.js test/platformGate.test.js test/stableHandlers.test.js test/vitrine.test.js test/vitrineGuard.test.js test/composePolish.test.js test/screensPolish.test.js test/themeUsage.test.js`: 9 arquivos, 0 falha.
+- [x] `npm test -w apps/app -- test/garden.test.js test/varandinhaView.test.js` (com as telas presentes): 0 falha.
+- [x] `npm test -w apps/app -- test/legal.test.js test/terms-version.test.js`, `npm test -w apps/site` e `npm test -w packages/core -- test/terms.test.js`: 0 falha.
+- [x] `node apps/site/scripts/render-legal.js --check`: as duas páginas iguais à saída do gerador.
+- [x] `npx standard` nos arquivos alterados.
+
+## CI completa
+
+- [x] `npm run lint`
+- [x] `npm test -- --affected=origin/main`: 844 arquivos de teste, 0 falha (Node 24). A primeira rodada falhou em `apps/app/test/feiraCompose.test.js`, que fixava o texto antigo de `backGuardRef`; o teste agora fixa o conjunto de guardas e passou.
+- [x] `npm run demo` termina com "DEMO OK"
+
+## No aparelho
+
+Limite conhecido: o build de debug (`app.varanda.debug`) não entra com passkey (AGENTS.md); por isso Android e iOS usam o Modo Vitrine, com `EXPO_PUBLIC_VARANDA_VITRINE=1`, depois de `npm run prepare:native -w apps/app`. Nunca `expo prebuild`. O fluxo com rede e duas contas se confere na web.
+
+### Android (emulador, build de debug, Vitrine, Metro 8105), cada item com captura de tela
+
+- [x] A Varandinha abre pelo Diário com dados de exemplo e sem rede: seis vasos em estágios diferentes, "Quem regou" com dois nomes e a linha Varandas da rua.
+- [ ] A entrada por Ajustes (abaixo de Visitas) não foi aberta no aparelho; a linha e o handler são conferidos por `composePolish.test.js` e `nav.test.js`.
+- [x] Vaso vazio: a folha lista as seis plantas; plantar mostra a barra "1 ação por guardar". Guardar grava (aviso "Varanda guardada.") e Descartar esvazia a fila sem gravar.
+- [ ] Regar o próprio vaso e colher não foram tocados no aparelho; o redutor é o mesmo de `rpc.garden.applyActs`, coberto por `apps/app/test/garden.test.js`.
+- [x] Varandas da rua lista as duas varandas de exemplo; abrir uma mostra de quem é a varanda (avatar e nome) e a linha de contagem.
+- [x] Regar a varanda de um vizinho: aviso "Você regou esta varanda." e o botão some; um vizinho já regado hoje não oferece Regar.
+- [x] Sair da Varandinha pede confirmação, com o texto inteiro; depois a tela mostra o estado desligado com Começar. O aviso de participação mostra as cinco linhas, a chave começa desligada e Começar fica inativo até ligar. Ligar de novo volta com os vasos vazios.
+- [x] Com "1 ação por guardar", o Voltar do Android abre "Sair sem guardar?". "Continuar na varanda" mantém a fila; Voltar e "Descartar e sair" voltam ao Diário.
+- [x] Varandas da rua, já com o filtro pela própria lista de quem a pessoa segue, lista Cecília e André, que a conta de exemplo segue.
+- [ ] Sair enquanto Guardar ainda está gravando não foi conferido no aparelho (a tela sai sem perguntar; correção abaixo).
+- [x] Escuro e claro; texto grande (escala de fonte 1,3) sem corte; movimento reduzido para o balanço das plantas prontas. No Android o React Native lê `transition_animation_scale`, não só `animator_duration_scale`: com só a segunda em 0 as plantas continuavam balançando. As configurações do emulador voltaram ao normal depois.
+
+### iOS (simulador iPhone 17 Pro, build de debug, Vitrine, Metro 8105), cada item com captura de tela
+
+- [x] A Varandinha abre pelo Diário com os dados de exemplo; a entrada por Ajustes não foi aberta.
+- [x] Plantar mostra a barra "1 ação por guardar", acima do indicador de início do iPhone; Guardar esvazia a fila.
+- [x] Varandas da rua lista as duas varandas; a varanda de um vizinho mostra de quem é e "1 vizinho regou".
+- [x] Um vaso pronto não oferece Regar, e a linha diz "pronta · terra seca", sem repetir "pronta".
+- [x] A varanda de Cecília, que a conta de exemplo já regou hoje (registro dos dados de exemplo), não oferece Regar. A de André oferece; regar mostra o aviso e a contagem passa a "1 vizinho regou" na hora.
+- [x] Sair pede confirmação; o estado desligado mostra Começar; o aviso de participação mostra as cinco linhas, com a chave desligada, no escuro e no claro.
+- [ ] Texto grande e movimento reduzido não foram conferidos no iOS (conferidos no Android).
+
+### Web (Vitrine no navegador, Metro 8105)
+
+- [x] 375x812 e 1280x800, escuro: a varanda abre pelo Diário; plantar mostra a barra (em 375 o texto "1 ação por guardar" quebra em duas linhas e cabe); Guardar esvazia a fila depois da pequena espera da Vitrine. Em 1280 a tela fica na coluna central.
+- [ ] Claro na web: o app usa o tema salvo e não seguiu o esquema emulado; o claro foi conferido no Android e no iOS.
+- Observação: um clique da automação durante a subida da folha de um vaso caiu no vaso 1, atrás da folha, e um clique seguinte completou esse toque e abriu a folha do vaso 1. Vem da folha compartilhada (`ui/Sheet`) no react-native-web, não desta tela; não foi corrigido aqui.
+
+### Web (`apps/cli/scripts/hosted-lab.js`, duas contas), não executado
+
+- [ ] A opta pelo jogo, planta e usa Guardar.
+- [ ] B, que segue A, rega a varanda de A uma vez.
+- [ ] A segunda rega de B no mesmo dia é recusada.
+- [ ] A vê o nome de B em "Quem regou".
+- [ ] Uma conta que não segue A é recusada ao regar.
+- [ ] Sair marca os registros do jogo como apagados (`diary.peek`).
+- [ ] Os Termos e a Privacidade estão na versão 78 e pedem novo aceite.
+- [ ] Núcleo: no `varanda-serve` e no app com configuração manual, a tela não oferece o jogo.
+
+O fluxo com rede é coberto por `packages/web-member/test/garden-e2e.test.js` (PR feat/varandinha-node), com um semeador local.
+
+## Correções feitas durante a conferência
+
+- A Vitrine responde no relógio de demonstração (`fixtures.now`); sem ajuste, toda planta de exemplo aparecia pronta e nenhuma rega cabia na janela. `apps/app/src/gardenClock.js` lê esse relógio só em bundles da Vitrine, e as datas de `garden.state` na Vitrine ficam no mesmo relógio (`vitrine/request.js`).
+- A barra "N ações por guardar" ficava sob a barra de gestos do Android: ganhou a margem inferior da área segura.
+- A varanda de outra pessoa não dizia de quem era: ganhou uma linha com avatar e nome no topo.
+- O aviso de participação mostrava só quatro das cinco linhas e deixava de fora a linha sobre sair.
+- A folha de um vaso pronto dizia "pronta" duas vezes.
+- Regar aparecia na varanda de quem a pessoa já tinha regado hoje, ou depois do limite do dia, e o nó recusava. A tela agora usa a mesma regra do nó (`rpc.garden.helpAllowed`) sobre as regas que `garden.state` lista.
+- Depois de regar, a contagem ainda dizia "Ninguém regou ainda" até a próxima leitura do índice; agora conta a rega confirmada na hora (uma rega incerta não conta). Uma rega incerta se resolve na próxima leitura da varanda: `garden.state` a lista quando foi gravada, e Regar some.
+- Com ações por guardar, a seta do topo perguntava antes de sair, mas o Voltar do Android e o Esc na web saíam sem perguntar. Agora os três perguntam. App.js guarda um conjunto de guardas de volta, e cada um só responde quando a sua tela está no topo. Enquanto Guardar ainda está gravando, sair não pergunta nada: a jogada já foi para o nó, e a pergunta diria, sem razão, que ela seria descartada.
+- Varandas da rua mostrava qualquer chave que o semeador listasse. Agora só aparece quem está na própria lista de quem a pessoa segue (`follow.list`, lida de novo a cada primeira página). Se essa leitura falha, a tela mostra o erro e nenhuma lista (`streetKeys` em `src/garden.js`, com teste).
+
+## Limites
+
+- O gesto de voltar deslizando no iPhone e o Voltar do navegador não consultam a guarda e saem sem perguntar, como já acontece em Anunciar. As ações na fila não são gravadas nesse caso: nada é enviado ao sair.
+
+## Ordem de implantação
+
+1. Semeadores (as rotas `/index/garden/` e `/index/garden//rua`).
+2. O nó hospedado da web.
+3. Os apps.
diff --git a/packages/core/lib/terms.js b/packages/core/lib/terms.js
index 6aa441a3..7616d412 100644
--- a/packages/core/lib/terms.js
+++ b/packages/core/lib/terms.js
@@ -22,7 +22,7 @@ const PREFIX = 'varanda-terms-v1'
// Must always equal apps/app/src/legal.js LEGAL_VERSION (pinned by
// apps/app/test/terms-version.test.js). Bumped on every change to the text
// of either document, so members accept the new text again.
-const TERMS_VERSION = 77
+const TERMS_VERSION = 78
const VERSION_MAX = 9999
// A base64url nonce of at least 32 bytes of entropy.
const NONCE_RE = /^[A-Za-z0-9_-]{43,128}$/
diff --git a/packages/core/test/terms.test.js b/packages/core/test/terms.test.js
index 942e8bb4..0f759f2d 100644
--- a/packages/core/test/terms.test.js
+++ b/packages/core/test/terms.test.js
@@ -39,7 +39,7 @@ const FIELDS = {
test('constants', (t) => {
t.is(PREFIX, 'varanda-terms-v1')
- t.is(TERMS_VERSION, 77)
+ t.is(TERMS_VERSION, 78)
t.is(VERSION_MAX, 9999)
t.is(NONCE_RE.source, accountLink.NONCE_RE.source, 'same nonce rule as account-link')
t.ok(NONCE_RE.test('A-_9'.repeat(32)))