@axpecter/lync 2.3.3 → 3.0.0

package/state/Audience.luau

@@ -0,0 +1,126 @@
+--!strict
+--!optimize 2
+-- Who sees a partition, and what has changed about that since the last flush.
+
+local Recipients = require (script.Parent.Parent.channel.Recipients)
+local Types = require (script.Parent.Parent.Types)
+
+local Audience = {}
+
+-- Constants -----------------------------------------------------------
+
+-- What a player seeded into a key is marked with, which is a flush no diff ever runs under.
+const BEFORE = 0
+
+-- Types ---------------------------------------------------------------
+
+-- Who held a key at its last diff, under the number of the diff that put them there.
+export type Seen = { [Player]: number }
+
+-- One set's audiences: who each key is for, and who was holding it last time anyone asked.
+export type Audience = {
+    read of: { [any]: Types.Recipient },
+    read held: { [any]: Seen },
+    read wide: { [any]: boolean },
+    read moved: { [any]: boolean },
+    read now: { [any]: { Player } },
+    read gained: { Player },
+    read lost: { Player },
+    at: number,
+}
+
+-- Public --------------------------------------------------------------
+
+function Audience.new (): Audience
+    return {
+        of = {},
+        held = {},
+        wide = {},
+        moved = {},
+        now = {},
+        gained = {},
+        lost = {},
+        at = BEFORE,
+    }
+end
+
+-- A key's viewers, replacing whoever it had.
+function Audience.assign (of: Audience, key: any, to: Types.Recipient)
+    of.of[key] = to
+    of.moved[key] = true
+end
+
+-- Whether a key goes to everybody, which is what puts its sections on the shared list.
+function Audience.everyone (of: Audience, key: any): boolean
+    local to = of.of[key]
+    return to == nil or to == Recipients.ALL
+end
+
+-- Who holds a key, as the diff that ran this flush worked it out.
+function Audience.members (of: Audience, key: any): { Player }
+    local now = of.now[key]
+    if now ~= nil then return now end
+
+    now = {}
+    of.now[key] = now
+    return now
+end
+
+-- Who holds a key now, and who gained or lost it since the last time this asked.
+function Audience.diff (of: Audience, key: any, ready: Recipients.Ready)
+    table.clear (of.gained)
+    table.clear (of.lost)
+
+    local now = of.now[key]
+    if now == nil then
+        now = {}
+        of.now[key] = now
+    end
+
+    local to = of.of[key]
+    local open = to == nil or to == Recipients.ALL
+
+    if open and of.moved[key] ~= true then
+        table.clear (now)
+        return
+    end
+
+    local held = of.held[key]
+    if held == nil then
+        held = {}
+        of.held[key] = held
+    end
+
+    if of.wide[key] ~= false then
+        for player in ready do
+            held[player] = BEFORE
+        end
+    end
+
+    of.moved[key] = nil
+    of.wide[key] = open
+
+    local at = of.at + 1
+    of.at = at
+
+    Recipients.resolve (now, if open then Recipients.ALL else to :: Types.Recipient, ready)
+
+    for _, player in now do
+        if held[player] == nil then table.insert (of.gained, player) end
+        held[player] = at
+    end
+
+    -- Who stopped holding this key, which is who is owed a removal for everything under it.
+    for player, when in held do
+        if when == at then continue end
+
+        held[player] = nil
+        if ready[player] == nil then continue end
+
+        table.insert (of.lost, player)
+    end
+
+    if open then table.clear (held) end
+end
+
+return table.freeze (Audience)

package/state/Catchup.luau

@@ -0,0 +1,218 @@
+--!strict
+--!optimize 2
+-- What a client is owed of a partition it has only just been given, and what a flush pays of it.
+
+local Plan = require (script.Parent.Plan)
+local Sections = require (script.Parent.Sections)
+local Store = require (script.Parent.Store)
+
+local Catchup = {}
+
+-- Types ---------------------------------------------------------------
+
+-- One client's backlog on one partition: the slots it is owed, in the order they will go.
+export type Pending = {
+    read slots: { number },
+    read live: { [number]: boolean },
+    at: number,
+    count: number,
+}
+
+-- Every backlog a namespace is carrying, and how many of them are not yet empty.
+export type Catchup = {
+    read owed: { [Player]: { [any]: Pending } },
+    any: number,
+}
+
+-- Private -------------------------------------------------------------
+
+-- A partition's held slots, ascending, which is the whole of what a client meeting it is owed.
+local function holding (store: Store.Store): { number }
+    local ids = store.ids
+    local slots = {}
+    local count = 0
+
+    for slot = 1, store.high do
+        if ids[slot] == nil then continue end
+
+        count += 1
+        slots[count] = slot
+    end
+
+    return slots
+end
+
+-- A backlog finished with, taken off its client and off the count the reserve is owed under.
+local function finished (of: Catchup, owed: { [any]: Pending }, who: Player, key: any)
+    owed[key] = nil
+    of.any -= 1
+
+    if next (owed) == nil then of.owed[who] = nil end
+end
+
+-- Public --------------------------------------------------------------
+
+-- Every backlog a namespace is carrying, empty, which a session holds one of while it is open.
+function Catchup.new (): Catchup return { owed = {}, any = 0 } end
+
+-- The bytes a flush holds back from the shared plan while anything is catching up.
+function Catchup.reserve (over: { Sections.Layout }): number
+    local most = 0
+
+    for _, layout in over do
+        local one = layout.opening + layout.entry
+        if one > most then most = one end
+    end
+
+    return most
+end
+
+-- Players that have just been given a key, each seeded with everything the partition holds.
+function Catchup.gained (of: Catchup, key: any, players: { Player }, store: Store.Store)
+    if #players == 0 then return end
+
+    local slots = holding (store)
+    local total = #slots
+    if total == 0 then return end
+
+    for _, who in players do
+        local owed = of.owed[who]
+        if owed ~= nil and owed[key] ~= nil then continue end
+
+        if owed == nil then
+            owed = {}
+            of.owed[who] = owed
+        end
+
+        local live = {}
+        for _, slot in slots do
+            live[slot] = true
+        end
+
+        owed[key] = { slots = slots, live = live, at = 1, count = total }
+        of.any += 1
+    end
+end
+
+-- Slots a section has just carried to everybody, taken off every backlog that was owed them.
+function Catchup.retired (of: Catchup, key: any, slots: { number }, from: number, count: number)
+    if of.any == 0 then return end
+
+    for who, owed in of.owed do
+        local pending = owed[key]
+        if pending == nil then continue end
+
+        local live = pending.live
+        local left = pending.count
+
+        for index = from, from + count - 1 do
+            local slot = slots[index]
+            if live[slot] == nil then continue end
+
+            live[slot] = nil
+            left -= 1
+        end
+
+        pending.count = left
+        if left == 0 then finished (of, owed, who, key) end
+    end
+end
+
+-- A partition emptied, which takes every backlog on it away with it.
+function Catchup.cleared (of: Catchup, key: any)
+    if of.any == 0 then return end
+
+    for who, owed in of.owed do
+        if owed[key] ~= nil then finished (of, owed, who, key) end
+    end
+end
+
+-- Players that have just had a key taken away, which owes them nothing further of it.
+function Catchup.lost (of: Catchup, key: any, players: { Player })
+    if of.any == 0 then return end
+
+    for _, who in players do
+        local owed = of.owed[who]
+        if owed ~= nil and owed[key] ~= nil then finished (of, owed, who, key) end
+    end
+end
+
+-- A link that has closed, which is every backlog its client was carrying and no other client's.
+function Catchup.dropped (of: Catchup, who: Player)
+    local owed = of.owed[who]
+    if owed == nil then return end
+
+    for _ in owed do
+        of.any -= 1
+    end
+
+    of.owed[who] = nil
+end
+
+-- One chunk of what a client is owed of a partition, written where it was handed.
+function Catchup.next (
+    of: Catchup,
+    layout: Sections.Layout,
+    store: Store.Store,
+    who: Player,
+    key: any,
+    b: buffer,
+    pos: number,
+    room: number
+): number
+    local owed = of.owed[who]
+    if owed == nil then return pos end
+
+    local pending = owed[key]
+    if pending == nil then return pos end
+
+    local cut = Plan.keyframes (layout, room)
+
+    local frame = layout.frame
+    local slots = pending.slots
+    local live = pending.live
+    local ids = store.ids
+    local gens = store.gens
+
+    local total = #slots
+    local index = pending.at
+    local taken = 0
+    local gone = 0
+
+    while index <= total and taken < cut do
+        local slot = slots[index]
+        index += 1
+
+        if live[slot] == nil then continue end
+
+        --[[
+            A slot the store no longer holds, which is a record removed since the grant. `remove`
+            unbinds at the call and the slot retires when the removal is planned, so a backlog
+            outlives the record it names. Nobody is owed a keyframe for a record that is gone.
+        ]]
+        if ids[slot] == nil then
+            live[slot] = nil
+            gone += 1
+            continue
+        end
+
+        taken += 1
+        frame.slots[taken] = slot
+        frame.ids[taken] = ids[slot]
+        if gens ~= nil then frame.gens[taken] = gens[slot] end
+        live[slot] = nil
+    end
+
+    pending.at = index
+    pending.count -= taken + gone
+    if pending.count == 0 then finished (of, owed, who, key) end
+
+    if taken == 0 then return pos end
+
+    frame.key = key
+    frame.count = taken
+
+    return Sections.keyframe (layout, b, pos, store.columns)
+end
+
+return table.freeze (Catchup)

package/state/Coalesce.luau

@@ -0,0 +1,43 @@
+--!strict
+--!optimize 2
+-- One record's mutations across a flush: the net effect that ships, and the fields it named.
+
+local Wide = require (script.Parent.Parent.kernel.Wide)
+
+local Coalesce = {}
+
+-- Types ---------------------------------------------------------------
+
+--[[
+    What an entry has pending. `replace` is produced and never taken: an add onto a removal is a new
+    record under an old id, and a receiver has to be told the one it holds is gone before it is
+    handed another.
+]]
+export type Kind = "add" | "update" | "remove" | "replace"
+
+-- Public --------------------------------------------------------------
+
+--[[
+    Nothing pending takes whatever came. An update never changes what an entry is, since a keyframe
+    already states every field and a delta is still a delta. An add can only follow a removal, which
+    is a replace. A remove ends the entry, and ends it as nothing where the add it cancels never
+    reached anybody.
+]]
+function Coalesce.merge (was: Kind?, took: Kind): Kind?
+    if was == nil then return took end
+    if took == "update" then return was end
+    if took == "add" then return "replace" end
+    return if was == "add" then nil else "remove"
+end
+
+function Coalesce.touched (mask: Wide.Word, field: number): Wide.Word
+    return Wide.union (mask, Wide.bit (field))
+end
+
+-- Tested bit by bit and never read as a number, because the widest field is the sign.
+function Coalesce.migrates (mask: Wide.Word, key: number?): boolean
+    if key == nil then return false end
+    return Wide.meets (mask, Wide.bit (key))
+end
+
+return table.freeze (Coalesce)

package/state/Fieldset.luau

@@ -0,0 +1,177 @@
+--!strict
+--!optimize 2
+-- Which fields a delta section carries, and which of them changed on every slot it lists.
+
+local Bits = require (script.Parent.Parent.kernel.Bits)
+local Bytes = require (script.Parent.Parent.wire.Bytes)
+local Catalog = require (script.Parent.Parent.kernel.Catalog)
+local Log = require (script.Parent.Parent.kernel.Log)
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+
+local Fieldset = {}
+
+-- Constants -----------------------------------------------------------
+
+const LIST = Protocol.FIELDSET_LIST
+const MASK = Protocol.FIELDSET_MASK
+
+-- The two one-bit fields here, named apart because they say different things at different places.
+const MODE = 1
+const FLAG = 1
+
+const BYTE = Protocol.BYTE_BITS
+
+const NO_FIELD = "a fieldset naming a field this set has not got"
+const NO_FIELDS = "a fieldset naming no fields at all"
+const OUT_OF_ORDER = "a fieldset naming its fields out of order"
+const PADDED = "a fieldset leaving something in the bits above it"
+
+-- Types ---------------------------------------------------------------
+
+-- The fields a delta selected, and how each of them is covered.
+export type Chosen = {
+    mode: number,
+    count: number,
+    fields: { number },
+    full: { number },
+}
+
+export type Write = (b: buffer, at: number, of: Chosen) -> number
+export type Read = (b: buffer, at: number, into: Chosen) -> number
+
+-- One set's fieldset, compiled: the widths its two forms take and the pair that writes them.
+export type Fieldset = {
+    read over: number,
+    read width: number,
+    read widest: number,
+    read write: Write,
+    read read: Read,
+}
+
+-- Private -------------------------------------------------------------
+
+--[[
+    A section this endpoint could not have written, refused under the one code every such refusal
+    carries and the phrase the site that found it holds.
+]]
+function Fieldset.broken (said: string): never
+    local facts: Log.Facts = { said = said }
+    return Log.reject (Catalog.SECTION, facts)
+end
+
+-- Public --------------------------------------------------------------
+
+-- A set's fieldset, as the pair that lays one down and takes it back up.
+function Fieldset.of (over: number): Fieldset
+    local width = Bits.width (over - 1)
+    local listed = width * (over + 1)
+
+    local function write (b: buffer, at: number, of: Chosen): number
+        local count = of.count
+        local mode = if width * (count + 1) <= over then LIST else MASK
+        of.mode = mode
+
+        local held = Bytes.put (b, at * BYTE, MODE, mode)
+
+        if mode == LIST then
+            --[[
+                One less than the count, because a delta selecting nothing is not a delta. That is
+                what lets a set of one field spend nothing at all on its fieldset past the mode bit:
+                the count is a ranged int over one possibility and so is the field index, and both
+                are no bits.
+            ]]
+            held = Bytes.put (b, held, width, count - 1)
+            for index = 1, count do
+                held = Bytes.put (b, held, width, of.fields[index] - 1)
+            end
+        else
+            --[[
+                The cursor is held to the count, because what sits past it is the section before
+                this one's. A leftover equal to the field being asked about would set a bit for a
+                field this delta does not carry, and the reader would then read every field after it
+                at the wrong offset.
+            ]]
+            local reached = 1
+            for field = 1, over do
+                local on = if reached <= count and of.fields[reached] == field then 1 else 0
+                held = Bytes.put (b, held, FLAG, on)
+                reached += on
+            end
+        end
+
+        --[[
+            The coverage flags ride the same bit run rather than sitting beside the values they
+            speak for. Every boundary in a section is on a byte, so a flag there would cost a byte
+            per selected field where this costs a bit, and nothing else moves: a reader knows how
+            many follow the moment it has read the fieldset.
+        ]]
+        for index = 1, count do
+            held = Bytes.put (b, held, FLAG, of.full[index])
+        end
+
+        local byte = Bytes.aligned (b, held)
+        return byte
+    end
+
+    --[[
+        A reader turns away a fieldset an encoder could not have written, and stops there. Out of
+        order and empty are one comparison each and convict a repeat as well. A count past the
+        field count needs no test: that many ascending indices inside it do not exist.
+    ]]
+    local function read (b: buffer, at: number, into: Chosen): number
+        local mode, held = Bytes.take (b, at * BYTE, MODE)
+        into.mode = mode
+
+        local count = 0
+        if mode == LIST then
+            count, held = Bytes.take (b, held, width)
+            count += 1
+
+            local last = 0
+            for index = 1, count do
+                local one
+                one, held = Bytes.take (b, held, width)
+                one += 1
+
+                if one > over then Fieldset.broken (NO_FIELD) end
+                if one <= last then Fieldset.broken (OUT_OF_ORDER) end
+
+                into.fields[index] = one
+                last = one
+            end
+        else
+            for field = 1, over do
+                local on
+                on, held = Bytes.take (b, held, FLAG)
+                if on == 0 then continue end
+
+                count += 1
+                into.fields[count] = field
+            end
+            if count == 0 then Fieldset.broken (NO_FIELDS) end
+        end
+
+        into.count = count
+
+        for index = 1, count do
+            into.full[index], held = Bytes.take (b, held, FLAG)
+        end
+
+        local byte, clean = Bytes.aligned (b, held)
+        if not clean then Fieldset.broken (PADDED) end
+        return byte
+    end
+
+    return table.freeze ({
+        over = over,
+        width = width,
+        widest = math.ceil ((MODE + math.min (listed, over) + over) / BYTE),
+        write = write,
+        read = read,
+    })
+end
+
+-- The record a caller fills and a reader fills back, empty, which is one per set that has a delta.
+function Fieldset.chosen (): Chosen return { mode = LIST, count = 0, fields = {}, full = {} } end
+
+return table.freeze (Fieldset)