v1 state

activitySize

Activity

Activity is one programming action on a station.

recordActivity

recordActivity writes the next slot of the fixed-size ring (storage never grows): Rec(kind, by, numbers), the numbers the track (4 digits), the station (1), the start (6) and the time (6). The head is in the flow record.

activityOf

activities

activities returns up to limit records, newest first: the ring's slots before its head, read one by one (the ring fills from slot 0 and no slot is ever deleted, so the first empty one ends it).

Activities

Activities returns up to limit entries, newest first.

ActivityJSON

ActivityJSON returns the programming feed, newest first (limit \<= 64).

adminAddr

syncAdmin

syncAdmin adopts the mirror when the previous release changed it after this one's init (during the release's delay).

onlyAdmin

Admin

PendingAdmin

Ready

Ready tells the data realm that this release is on chain (see data.Propose). Anyone may call it.

OfferAdmin

OfferAdmin offers the admin role to an address (offering it to the admin cancels the offer); AcceptAdmin takes it. Each change is mirrored to the data realm, so the next release keeps the admin.

AcceptAdmin

RenounceAdmin

RenounceAdmin gives the admin role up for good, for this release and the next ones.

DropSlot

DropSlot silences a track in one station's rotation (moderation of last resort). It stays silent through Refresh until RestoreSlot. Radio admin only.

RestoreSlot

RestoreSlot undoes DropSlot: the track plays again on that station if the catalog still allows it. Radio admin only.

Unqueue

Unqueue removes a track's programmed slots from a station; one on air ends now. Radio admin (curator) only.

Render

Render points gnoweb visitors to the GnoRadio site; a retired release says which realm took over.

allStations

topCurators

topMax

// the longest station top: week, count, then score and key per curator

week

tipGrace

// seconds after a pick ends during which a tip still credits its picker

Curator

Curator is a picker's record, all time or for one week.

cWeek

A curator is one record: all time, picks, tips, earned, promo, first pick, period, picks this period, picks the period before (sponsor.gno); this week across stations, week, picks, tips, earned; each a fixed-width number (cWidths). Then one entry per station picked on lately: the station (1 digit), week, picks, tips, earned and the last pick time (sWidths).

cFields

A curator is one record: all time, picks, tips, earned, promo, first pick, period, picks this period, picks the period before (sponsor.gno); this week across stations, week, picks, tips, earned; each a fixed-width number (cWidths). Then one entry per station picked on lately: the station (1 digit), week, picks, tips, earned and the last pick time (sWidths).

cLen

// the numbers

sLen

// one station entry

cWidths

sWidths

TipOnAir

TipOnAir tips the artist of trackID: the attached ugnot go through the catalog, which pays the artist and collaborators exactly as catalog.TipWithSupport does. When trackID is a listener's pick on air on stationID (or ended less than two minutes ago), the artist's promo share goes to that listener; the radio reads the picker from its own schedule. ref is who shared the link the tipper came from ("" for none): picker and ref split the promo share, never more.

credit

credit adds picks or a shared tip to a curator, all time and this week. The station's entry also keeps the time of the last pick there, which the queue cooldown reads (lastPickAt): no extra write per pick.

curRec

curRec reads a curator record (zeros when absent) and its station entries.

putCur

stationOf

stationOf returns a curator's entry for a station: week, picks, tips, earned, last pick time (zeros when none).

withStation

withStation sets a station's entry and drops the entries that no longer count: an older week whose last pick is past the cooldown.

markPick

markPick keeps the time of a pick that earns no point (a sponsored one) for the queue cooldown.

lastPickAt

lastPickAt is when addr last picked on a station (0: never).

weekOf

weekOf numbers weeks from Monday 00:00 UTC.

rank

topRec

topRec is ranking i: 0 across stations, else station i-1's (in its record, which a pick there writes anyway).

top

top reads ranking i of week wk (nil when another week's).

setTop

setTop raises k's score in a ranking, emptied when a new week starts. Scores only grow, so a score below the last of a full top leaves it untouched (and unsaved): k cannot be in it. That is read without decoding the list.

CuratorOf

CuratorOf returns a listener's curator record, all time.

TopCurators

TopCurators returns this week's top curators of a station (allStations: every station), best first, with their counts for the week. Picks and tips received on air score one point each.

weekTop

CuratorJSON

CuratorJSON returns a listener's curator record: all time, this week, and their place in this week's top across stations (0 when outside the top 10).

TopCuratorsJSON

TopCuratorsJSON returns TopCurators as JSON with the week's start (unix).

cStations

// P(station) -> Rec(epoch, ring, live, rotation header, schedule, recent picks, weekly top\[, ring rotation, ring index])

cRot

// P(station)/b/P(block) -> block; P(station)/g/P(group) -> block sums (p/blocks)

cHomes

// P((id-1)/homesChunk) -> Rec of homes entries (the genre stations of a track), one per synced track

cMeta

// "flow" -> flow record

cCurators

// address -> curator record (curators.gno)

cTops

// "all" -> this week's top curators across stations (a station's is in its record)

cDropped

// P(station)/P(track) -> "1"

cNotes

// P(station)/T(start) -> reporters, or the strike a hide gave (notes.gno)

cMuted

// address -> unix time its dedications are refused until

cStrikes

// address -> unix time one of its dedications was last hidden

cSponsor

// address/P(station) -> open sponsored pick (sponsor.gno)

cActivity

// P(0..63) -> activity record (a ring, its head in the flow record)

cConfig

// "admin" (mirror of the admin role), "modbot" (hex key)

collections

homesChunk

// homes entries per key

maxRecord

// the data realm's longest value

setup

setup makes the radio's collections and its first records, once: a later release finds them made (it is not the writer in its init).

dec

Fixed-width base-64 numbers are store.Num, store.Fixed and store.AppendFixed. dec is store.Digits' decoding table, for the digits the hot loops read in place: a call per digit costs about 1% of a pick.

decTable

tx

tx reads each key from the data realm once and writes every key it changed once, in one call (data.Set or data.Batch); the stations it loaded are decoded once and encoded back when changed. Every entrypoint loads what it needs, changes it in its tx, then saves; readers use one too. A tx is never stored.

entry

rd

save

save writes what t changed: one data.Set or data.Remove, or Batches of 64 ops (a Sync or a RefreshArtist may change more keys than one Batch takes; the transaction keeps them atomic).

fSynced

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

fDrops

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

fHead

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

fTopWeek

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

fTopLast

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

fLive

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

flowLen

The flow record is fixed-width: synced (4 digits), the number of dropped slots (4), the activity ring's next slot (1), the week of the top across stations and its last score when it holds topCurators (0 else) (4 and 4: a pick that scores less leaves it as it is, unread), then "1" for each genre station with a live track ("0" else, index = genre): Main relays one of those (hourGenre). Every call reads it.

dropKey

station

station is a station loaded in a tx: its header and schedule are one record (cStations); its rotation is read and written a block at a time (cRot), but for New and Choice: their rings (at most 500 slots) and the index of the tracks in them are part of their record, which a pick changes anyway. The schedule is decoded on first use (slots): a call that only needs the time paused under it (paused) or a picker (picker) reads it as it is.

blockLen

A ring's rotation (one group) is its group's sums, 4 digits per block, then its blocks, blocks.Size slots each but the last.

decodeSchedule

encodeSchedule

cursor

cursor walks an encoded schedule a slot at a time without decoding it: after next, the slot's body is s\[b:i] and it plays from start to end.

idxW

// a ring index entry

homesKey

homeEntry

homeSlot

homeSlot finds a station's slot in an entry.

energy

energy orders the genres from calm to intense; neighbours blend well.

dayparts

dayparts is the target index in energy for each 3-hour block of the UTC day: Jazz, Ambient, Lo-fi, World, Pop, Rock, House, then Drum & Bass at the peak.

hourGenre

hourGenre is the genre Main relays at ts: the daypart's target, one step below it in the block's first hour, above it in the last, or the nearest genre with a live track (0: none).

HourGenre

HourGenre is the genre Main relays at unix time at (0: none), for pages that explain it.

ScheduleJSON

ScheduleJSON returns what a station plays from now until now+horizon seconds (60..7200, at most 60 entries): programmed slots and the rotation between them (on Main, the hour's genre station, simulcast and cut at each hour). A client plays entry i from offset+max(0, clock-start) and resyncs on "now". "relay" marks, on Main, an entry that is not Main's own slot but the hour's genre station simulcast (its picks included). "sponsored" is the refund its artist pays the picker (0: a normal pick), "at" the time a booked pick asked for (0: none). "booked" lists every booked pick still to air, whatever the horizon, and those that aired in the last hour (they count toward their clock hour's cap until they fold): {"track","start","end","at","by","note"}. Fetch it again every few minutes, not every second.

StationsJSON

StationsJSON lists every station with what it plays now.

struckMark

noteKey

ReportNote

ReportNote flags the dedication of the slot starting at start. Only a listener with the reputation sponsored picks need (a first pick a week old, 3 normal picks this 15-day period and the one before: sponsorBlock) may report, so throwaway wallets cannot; the third such listener hides it at once, with no moderator involved. A first hidden dedication is a strike; a second within muteFor pauses its author's dedications for muteFor (the admin can lift it: Unmute).

RestoreNote

RestoreNote shows again a dedication hidden by reports by mistake and clears its author's strike (Unmute lifts a pause). Radio admin only.

SetModBot

SetModBot names the moderation robot by its Ed25519 public key in hex ("" turns dedications off). Radio admin only.

MutedUntil

MutedUntil returns the unix time until which who's dedications are paused after reports, 0 when they are not: the moderation robot refuses to sign for a muted author.

Unmute

Unmute lets a muted listener dedicate again before the week ends, e.g. after reports by throwaway wallets. Radio admin only.

noteSlot

noteSlot finds the dedicated slot starting at start. On Main between its own picks it is the genre station's slot Main simulcast: the genre of the hour the slot began in, or of now when the hour changed under it.

PublishTrack

PublishTrack publishes a track by the caller's own artist profile (the arguments are catalog.PublishFor's) and puts it on the air in the same transaction: the main station, its genre station and New this week.

ImportTrack

ImportTrack adds a curated or Audius track to an unclaimed artist (the arguments are catalog.ImportFor's) and puts it on the air, New this week left out: an import is not a new release. The catalog admin only, from its wallet or a realm that holds the role (a launch import).

maxImportBatch

maxImportBatch bounds ImportTracks: each track costs a few M gas once the realms are loaded, so a full batch stays far under the block's gas.

ImportTracks

ImportTracks imports up to maxImportBatch tracks in one transaction, so the realms load once for the batch instead of once per track. batch holds one track per line ("\\n"), ImportTrack's 12 arguments separated by tabs ("\\t"; neither can appear in a valid field). All or nothing: a bad track panics the whole transaction (a malformed line is named before anything is written). It returns the id of the last track. Admin only, as ImportTrack.

EditTrack

EditTrack fixes a track's details (the arguments are catalog.EditFor's). A new genre or duration is applied to the stations in the same transaction, as Refresh does; other details need nothing on air.

onAir

onAir ingests the track the catalog just added, with Sync's own code: it is the next one (Sync and every add keep the stations level with the catalog), so this is one track's work whatever the catalog size.

airNext

Queue

Queue programs a track on a station and adds it to Listeners' choice. It starts after the last track a listener programmed, or when the song on air ends: nothing is cut. On Main it starts at once over the hour's relay (the app crossfades), which resumes after it. Limits per station: one waiting slot per listener, two per artist, a track at most once, 30 upcoming.

QueueAt

QueueAt is Queue for a chosen time: at (unix, UTC) between 15 minutes and 24 hours from now; 0 is Queue. The pick starts at the first track boundary at or after at (on Main, at at: the relay's track fades out as for any pick), unless listener picks fill that moment, then right after them. It keeps its time: later picks go before it only if they end by then, else after it. Every Queue rule applies, the 3-hour replay gap around at; the 2-hour airtime cap does not, but at most 4 picks are booked per station and clock hour and at most 15 booked picks wait per station.

QueueWithNote

QueueWithNote is Queue with a dedication shown on air ("for Marie!"). The moderation robot judges it before the transaction (word filter and a moderation model, app/netlify/functions/dedication.mts) and signs NoteMessage(note, expires): the listener sends that certificate and pays their own gas, so a dedication shows at once and costs GnoRadio nothing. It must also pass p/gnoradio/safe (plain text, no link, no blocked word). Listeners can report it: three reports hide it and give its author a strike; a second hidden dedication within a week pauses their dedications for a week (ReportNote). The pause is per wallet: an author can dedicate again from a fresh one, which reports hide and pause the same way (accepted residual; the robot and the word filter still judge every note).

QueueWithNoteAt

QueueWithNoteAt is QueueWithNote for a chosen time (see QueueAt; 0: now).

queueWithNote

NoteMessage

NoteMessage is what the moderation robot signs to approve a dedication by author on stationID until expires (unix seconds), on this chain and this GnoRadio deployment (its data realm) only: "gnoradio-note|\<chain id>|\<data realm>|\<author>|\<station>|\<note>|\<expires>". A certificate seen in a public transaction serves no other wallet, station or deployment.

checkNote

CuratorQueue

CuratorQueue programs a track like Queue but without the per-listener and per-artist quotas (the duplicate, genre and queue-size rules still apply). Radio admin only.

queue

insert

insert puts s in a schedule, sorted by start, and returns its index.

noteReserve

noteReserve is the record room the other plain picks a station may still take need: a slot and a replay entry each, plus its curator top at full.

NumGenres

NumGenres is the catalog's: genre stations are 1..NumGenres.

MainStation

Station ids are stored keys in the permanent data realm (schedules, drops, notes, curator ranks): Main 0, genres 1..NumGenres, New, Choice. A later release must keep them, and add any new station after Choice.

NewStation

// the newest newCap ingested tracks

ChoiceStation

// the last choiceCap distinct listener picks

numStations

Station ids are stored keys in the permanent data realm (schedules, drops, notes, curator ranks): Main 0, genres 1..NumGenres, New, Choice. A later release must keep them, and add any new station after Choice.

newCap

Station ids are stored keys in the permanent data realm (schedules, drops, notes, curator ranks): Main 0, genres 1..NumGenres, New, Choice. A later release must keep them, and add any new station after Choice.

choiceCap

Station ids are stored keys in the permanent data realm (schedules, drops, notes, curator ranks): Main 0, genres 1..NumGenres, New, Choice. A later release must keep them, and add any new station after Choice.

maxQueue

// upcoming slots per station

maxPerArtistQ

// upcoming slots per artist and station

maxSyncBatch

Station ids are stored keys in the permanent data realm (schedules, drops, notes, curator ranks): Main 0, genres 1..NumGenres, New, Choice. A later release must keep them, and add any new station after Choice.

maxRefreshBatch

Station ids are stored keys in the permanent data realm (schedules, drops, notes, curator ranks): Main 0, genres 1..NumGenres, New, Choice. A later release must keep them, and add any new station after Choice.

foldAfter

// programmed slots ended this long ago fold into the epoch

queueCooldown

// a listener may queue once per station per hour

replayGap

// a track picked on a station cannot be picked there again for 3 hours, by anyone

maxAheadAir

// listener-programmed airtime ahead on a station, seconds

maxNote

// characters of a dedication

noteCertLife

// seconds a moderation certificate may still have to live

hideAfter

// distinct reputable listeners (sponsorBlock) reporting a dedication hide it

muteFor

// a second hidden dedication within this time mutes its author this long

bookMin

// a pick booked for a time: at least this far ahead

bookMax

// and at most this far

maxBookedHour

// booked picks per station and clock hour (UTC)

maxKept

// listener slots a station keeps, aired ones included until they fold

maxBooked

// booked picks waiting per station

maxTrack

// the catalog's longest track, seconds

recordHeadroom

// bytes a station record keeps free for the writes that follow a pick

plainSlot

// record bytes of a listener slot without a dedication: 25, an address, at most 7 of gap

dataPath

dataPath is the data realm: certificates are bound to it.

Slot

Slot is a track a listener (or a curator) programmed on a station. Dur is captured when queued so later catalog edits cannot move the timeline.

self

// this realm's path

admin

// the radio admin; nil when a release before renounced it

init.153

Sync

Sync ingests up to max catalog tracks not yet on the stations into the main station, the station of their genre and New; the catalog's most liked tracks join Listeners' choice. Main's flow needs no Sync (flow.gno). Anyone may call it. PublishTrack and ImportTrack put each new track on the air themselves (publish.gno), so this is a safety net: a track is never ingested twice (the flow record counts the synced ones). A track that is not playable yet is added silent (duration 0) and Refresh turns it on.

ingest

ingest adds up to max newly published tracks to the stations, and to New when joinNew (a launch-catalog import is not a new release).

Refresh

Refresh re-reads a track from the catalog and updates its rotation slots: a hidden track goes silent, a restored one comes back, an edited duration is applied. Programmed slots of a track that is no longer playable are dropped. Anyone may call it. A slot the admin dropped stays silent.

RefreshArtist

RefreshArtist refreshes up to maxRefreshBatch synced tracks of an artist, from offset in the artist's track list, so hiding (or restoring) a whole artist takes a few calls instead of one per track. It returns the offset to pass next, or 0 when the list is done. Anyone may call it.

refresh

NowPlaying

NowPlaying returns what a station plays at the last block: the track, the offset into it in seconds, and whether a listener programmed it. trackID is 0 when nothing plays. Clients should prefer ScheduleJSON and their clock.

OnAirNote

OnAirNote returns the dedication of the programmed slot on air ("" when none, or once reports hid it).

OnAirPay

OnAirPay is the refund of the sponsored pick on air (0: none), for labels.

UpNext

UpNext returns the slots listeners programmed on a station that have not started yet.

StationCount

StationCount returns the number of stations (ids 0..StationCount()-1).

StationName

StationName is "Main", the genre name, "New this week" or "Listeners' choice".

StationInfo

StationInfo returns how many tracks rotate on a station and the loop length.

Pending

Pending returns how many catalog tracks are not on the stations yet: 0, since publishing puts a track on the air (Sync is the safety net).

PickRules

PickRules returns the limits on listeners' picks, for pages that explain them: one pick per cooldown per station, a track not again within replay, at most ahead seconds and queue slots waiting, perArtist waiting per artist, booked picks bookFrom to bookTo ahead, bookedPerHour per clock hour and booked of the queue slots at most.

now

mustStation

userCaller

noPayment

abs64

max64

repPeriod

// reputation counters roll over every 15 days

repAge

// a wallet's first pick must be this old

repPicks

// normal picks this period and the one before

sponsorShare

sponsorWindow

sponsorKey

QueueSponsored

QueueSponsored is Queue paid by the artist: once the pick has aired in full, ClaimPickPayout sends the picker the artist's refund (catalog PromoOffer). No dedication. A wallet has one sponsored pick open per station: it must be collected (or have lapsed) before the next.

QueueSponsoredAt

QueueSponsoredAt is QueueSponsored for a chosen time (see QueueAt; 0: now). The refund lapses 7 days after the booked time plus the track's length.

queueSponsored

ClaimPickPayout

ClaimPickPayout sends the caller the refund of their sponsored pick that started at start on stationID, once it has aired in full.

sponsorBlock

sponsorBlock says why a wallet may not take sponsored picks yet ("" when it may).

sponsorQuota

sponsorQuota: one sponsored pick per artist per station and hour, and sponsored airtime at most a quarter of the listener window, both around airs (now, or the time booked). The share counts the listener window from airs; the per-artist hour is checked around plays, when the pick really airs (review R31).

reserve

reserve books the artist's refund for a sponsored slot, lapsing after held.

hold

hold is a sponsored slot's reservation in the catalog: filed under the end it was reserved for (the slot may have moved since). reserved is when it was taken, 0 once the slot started airing: only a pick that never aired gives its daily counts back.

unsponsor

unsponsor forgets the open record of a sponsored slot cut at ts before it started, and returns its reservation; ok is false when there was none. A slot already on air keeps its record: whoever cut it (a hide, a genre edit, a drop), the picker earned the refund and collects it once its end passes.

release

release gives the reservations of cut sponsored slots back to their artists. While the catalog is paused it gives nothing back, so the radio can still drop slots: each hold lapses back to its budget by itself.

PickPayoutStatus

PickPayoutStatus says what ClaimPickPayout would do for addr's sponsored pick that started at start on stationID: "ok" (it pays), "airing" (not finished yet), "lapsed" (nothing to pay: lapsed or cancelled; collecting only clears it) or "none" (no such open pick).

payoutStatus

SponsoredJSON

SponsoredJSON lists a wallet's sponsored picks not collected yet, with whether it may take new ones and each one's PickPayoutStatus: {"block":"why not, or empty","open":\[{"station","start","track","end","amount","status"}]}.

choose

choose adds a synced track to Listeners' choice unless it is already there.

pickW

The replay record of a station (in its record: a pick changes both) is fixed-width entries, the track (4 digits) then the pick time (6), read by slicing.