@axpecter/lync 2.3.3 → 3.0.0

package/shape/Compile.luau

@@ -0,0 +1,340 @@
+--!strict
+--!optimize 2
+-- A namespace of declarations as the frozen records every layer above reads it by.
+
+local Base = require (script.Parent.Parent.codec.Base)
+local Frames = require (script.Parent.Frames)
+local Legality = require (script.Parent.Legality)
+local Log = require (script.Parent.Parent.kernel.Log)
+local Order = require (script.Parent.Order)
+local Serial = require (script.Parent.Serial)
+local Shape = require (script.Parent)
+local Types = require (script.Parent.Parent.Types)
+local Wide = require (script.Parent.Parent.kernel.Wide)
+
+local Compile = {}
+
+-- Constants -----------------------------------------------------------
+
+-- What a template holds in every field, which is a place rather than a value.
+const PLACE = false
+
+-- Types ---------------------------------------------------------------
+
+-- What one definition costs, as the two numbers a caller of it can want.
+export type Packet = {
+    read id: number,
+    read name: string,
+    read kind: "packet",
+    read maxBytes: number,
+    read file: string,
+    read line: number,
+    read built: Shape.Built,
+    read head: Frames.Head,
+    read blockBytes: number,
+    read delivery: Serial.Delivery,
+    read hz: number?,
+    read timestamped: boolean,
+}
+
+--[[
+    A query holds two builds and one id, and its response is that id and one. A frame carries a
+    single axis and no kind bit, so which half arrived is read off whether the id is the one the
+    record carries, a comparison the router already holds both sides of.
+]]
+export type Query = {
+    read id: number,
+    read name: string,
+    read kind: "query",
+    read maxBytes: number,
+    read file: string,
+    read line: number,
+    read request: Shape.Built,
+    read response: Shape.Built,
+    read asks: Frames.Head,
+    read answers: Frames.Head,
+    read blockBytes: number,
+}
+
+--[[
+    A set is its fields, so what it carries is per field and in one order. The record's own cell is
+    here and its own build is not, since a section never writes a whole record and the cell is all
+    the descriptor ever wanted. Which fields may hold nothing and which may only climb are beside
+    the builds, because reading either off a cell at the call would be `state` reading a codec.
+]]
+export type Set = {
+    read id: number,
+    read name: string,
+    read kind: "set",
+    read maxBytes: number,
+    read file: string,
+    read line: number,
+    read cell: Base.Cell,
+    read head: Frames.Head,
+    read stream: Frames.Head,
+    read keyField: string?,
+    read keyIndex: number?,
+    read fieldNames: { string },
+    read fieldIndex: { [string]: number },
+    read fieldBuilt: { Shape.Built },
+    read fieldCount: number,
+    read newestFields: { number },
+    read optionalFields: { boolean },
+    read climbingFields: { boolean },
+    read template: { [string]: any },
+    read site: Shape.Site,
+}
+
+-- The marker vocabulary, re-exported rather than reached for.
+export type Marker = Base.Marker
+
+export type Def = Packet | Query | Set
+
+--[[
+    A namespace, compiled. `count` is how many ids were handed out rather than how many definitions
+    there are, because a defId is a ranged int over exactly that and a query took two.
+]]
+export type Compiled = {
+    read space: string,
+    read descriptor: string,
+    read hash: Wide.Word,
+    read count: number,
+    read list: { Def },
+    read byName: { [string]: Def },
+    read byId: { [number]: Def },
+}
+
+-- A set's fields, as the four arrays a column walk reads and the bytes one record comes to.
+type Fields = {
+    names: { string },
+    index: { [string]: number },
+    built: { Shape.Built },
+    newest: { number },
+    optional: { boolean },
+    climbs: { boolean },
+    template: { [string]: any },
+    site: Shape.Site,
+    bytes: number,
+}
+
+-- Private -------------------------------------------------------------
+
+-- A handle as the declaration it carries.
+local function declared (of: Types.Definition): Legality.Declared return of :: any end
+
+-- A set's fields, in the order their columns are indexed by.
+local function columns (name: string, cell: Base.Cell): Fields
+    local fields = cell.children :: { [string]: Base.Cell }
+    local names = Order.names (fields)
+    local reach = #names
+
+    local built = table.create (reach) :: { Shape.Built }
+    local place: { [string]: number } = {}
+    local newest: { number } = {}
+    local optional = table.create (reach) :: { boolean }
+    local climbs = table.create (reach) :: { boolean }
+    local template: { [string]: any } = {}
+    local bytes = 0
+
+    --[[
+        One site for the whole set rather than one a field, everything in it numbered from
+        nothing. A section is one block over every field and a boundary holds the definition, so
+        fields numbering into tables of their own would each start again at one.
+    ]]
+    local site: Shape.Site = {
+        paths = Serial.interner (),
+        expected = Serial.interner (),
+        sidecar = { refs = {}, slotOf = {}, bears = false },
+    }
+
+    for index, field in names do
+        local held = fields[field]
+        local one = Shape.build (Base.codec (held), Serial.under (name, field), site)
+
+        built[index] = one
+        place[field] = index
+        bytes += one.maxBytes
+        template[field] = PLACE
+        optional[index] = held.kind == "optional"
+        climbs[index] = held.marker == "monotonic"
+
+        if held.marker == "newest" then table.insert (newest, index) end
+    end
+
+    return {
+        names = table.freeze (names),
+        index = table.freeze (place),
+        built = table.freeze (built),
+        newest = table.freeze (newest),
+        optional = table.freeze (optional),
+        climbs = table.freeze (climbs),
+        template = table.freeze (template),
+        site = site,
+        bytes = bytes,
+    }
+end
+
+-- One declaration as the record it becomes, at the id and under the count it was given.
+local function made (name: string, id: number, over: number, of: Legality.Declared): Def
+    local at = of.at
+
+    if of.kind == "packet" then
+        local built = Shape.build (of.of, name)
+        local lane = Legality.delivery (of)
+
+        --[[
+            A newest packet's block is a different form rather than the same one differently filled:
+            it carries a sequence and never a continuation, because its senders coalesce to one
+            value before it is sequenced and a bit saying so would never be anything else.
+        ]]
+        local head = if lane == "newest"
+            then Frames.newest (over, of.isTimestamped)
+            else Frames.packet (over, of.isTimestamped)
+
+        local bytes = Frames.block (head, built.maxBytes)
+        Legality.block (name, of, bytes)
+
+        return table.freeze ({
+            id = id,
+            name = name,
+            kind = "packet" :: "packet",
+            maxBytes = built.maxBytes,
+            file = at.file,
+            line = at.line,
+            built = built,
+            head = head,
+            blockBytes = bytes,
+            delivery = lane,
+            hz = of.hz,
+            timestamped = of.isTimestamped,
+        })
+    end
+
+    --[[
+        A query is two blocks at two ids, so it is two heads, and what one costs is the wider of
+        them. Neither is held to a ceiling: both ride the reliable lane, which is never split and is
+        bounded by the budget rather than by what one fire carries.
+    ]]
+    if of.kind == "query" then
+        local request = Shape.build (of.of, Serial.under (name, Legality.REQUEST))
+        local response = Shape.build (of.reply, Serial.under (name, Legality.RESPONSE))
+
+        local asks = Frames.request (over)
+        local answers = Frames.response (over)
+
+        return table.freeze ({
+            id = id,
+            name = name,
+            kind = "query" :: "query",
+            maxBytes = math.max (request.maxBytes, response.maxBytes),
+            file = at.file,
+            line = at.line,
+            request = request,
+            response = response,
+            asks = asks,
+            answers = answers,
+            blockBytes = math.max (
+                Frames.block (asks, request.maxBytes),
+                Frames.block (answers, response.maxBytes)
+            ),
+        })
+    end
+
+    local cell = Base.cell (of.of)
+    local held = columns (name, cell)
+    local key = of.keyField
+
+    return table.freeze ({
+        id = id,
+        name = name,
+        kind = "set" :: "set",
+        maxBytes = held.bytes,
+        file = at.file,
+        line = at.line,
+        cell = cell,
+        head = Frames.section (over),
+        stream = Frames.stream (over, #held.names),
+        keyField = key,
+        keyIndex = if key == nil then nil else held.index[key],
+        fieldNames = held.names,
+        fieldIndex = held.index,
+        fieldBuilt = held.built,
+        site = held.site,
+        fieldCount = #held.names,
+        newestFields = held.newest,
+        optionalFields = held.optional,
+        climbingFields = held.climbs,
+        template = held.template,
+    })
+end
+
+-- A definition as the descriptor writes it.
+local function framed (of: Def): Serial.Frame
+    if of.kind == "packet" then
+        return {
+            kind = "packet",
+            of = of.built,
+            delivery = of.delivery,
+            hz = of.hz,
+            timestamped = of.timestamped,
+        }
+    end
+
+    if of.kind == "query" then return { kind = "query", of = of.request, reply = of.response } end
+    return { kind = "set", of = { cell = of.cell }, keyField = of.keyField }
+end
+
+-- Public --------------------------------------------------------------
+
+-- A namespace's declarations, refused or compiled, as one frozen record.
+function Compile.build (space: string, specs: Types.Definitions): Compiled
+    local why = Legality.named (space)
+    if why ~= nil then Log.refuse (`the namespace {space} {why}`) end
+
+    local names = Order.names (specs)
+
+    -- How many ids there are, before any of them is handed out.
+    local over = 0
+    for _, name in names do
+        over += if declared (specs[name]).kind == "query" then 2 else 1
+    end
+
+    local list = table.create (#names) :: { Def }
+    local byName: { [string]: Def } = {}
+    local byId: { [number]: Def } = {}
+    local frames: { [string]: Serial.Frame } = {}
+
+    local at = 0
+    for _, name in names do
+        local of = declared (specs[name])
+        Legality.definition (name, of)
+
+        local def = made (name, at, over, of)
+        table.insert (list, def)
+        byName[name] = def
+        frames[name] = framed (def)
+
+        byId[at] = def
+        if def.kind ~= "query" then
+            at += 1
+            continue
+        end
+
+        byId[at + 1] = def
+        at += 2
+    end
+
+    local descriptor = Serial.namespace (space, frames)
+
+    return table.freeze ({
+        space = space,
+        descriptor = descriptor,
+        hash = Serial.hash (descriptor),
+        count = over,
+        list = table.freeze (list),
+        byName = table.freeze (byName),
+        byId = table.freeze (byId),
+    })
+end
+
+return table.freeze (Compile)

package/shape/Folds.luau

@@ -0,0 +1,332 @@
+--!strict
+--!optimize 2
+-- A declaration whose value comes apart by a computation, as the leaves it takes and the pair.
+
+local Base = require (script.Parent.Parent.codec.Base)
+local Grid = require (script.Parent.Grid)
+local Ir = require (script.Parent.Ir)
+local Joins = require (script.Parent.Joins)
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+local Rotation = require (script.Parent.Rotation)
+local Scalars = require (script.Parent.Parent.codec.Scalars)
+
+local Folds = {}
+
+-- Types ---------------------------------------------------------------
+
+-- What a fold becomes, which is what a field the language carries becomes and for one reason.
+export type Field = Joins.Field
+
+-- Constants -----------------------------------------------------------
+
+-- What the engine calls each of the four this file takes apart.
+const PLANE = "Vector2"
+const VECTOR = "Vector3"
+const FRAME = "CFrame"
+const COLOUR = "Color3"
+
+-- The same four, under the kinds that declare them.
+Folds.ENGINE = table.freeze ({
+    vec2 = PLANE,
+    vec3 = VECTOR,
+    color3 = COLOUR,
+    cframe = FRAME,
+})
+
+-- The four a smallest three chooses between, which is what its tag is a ranged int over.
+const CORNERS = Protocol.QUAT_W + 1
+
+-- How far past its first leaf the last of those four sits.
+const LAST = CORNERS - 1
+
+-- What a packed colour spends on each of its three, which is named one at a time.
+const RED = Protocol.RGB565_RED
+const GREEN = Protocol.RGB565_GREEN
+const BLUE = Protocol.RGB565_BLUE
+
+-- Private -------------------------------------------------------------
+
+-- A fold, as the one shape every form below answers in.
+export type Fold = {
+    leaves: { Grid.Grid },
+    pull: (value: any, into: { number }, at: number) -> boolean,
+    push: (from: { number }, at: number) -> any,
+}
+
+-- The components of a vector, one grid each, in the order they are written.
+local function spread (of: Grid.Grid, wide: boolean): Fold
+    local toIndex, fromIndex = of.toIndex, of.fromIndex
+
+    local leaves = if wide then { of, of, of } else { of, of }
+
+    -- Both widths come through here, so what it is handed is whichever the leaves say it took.
+    local wanted = if wide then VECTOR else PLANE
+
+    local function pull (value: any, into: { number }, at: number): boolean
+        if typeof (value) ~= wanted then return false end
+
+        local x, y = toIndex (value.X), toIndex (value.Y)
+        if x == nil or y == nil then return false end
+
+        if not wide then
+            into[at], into[at + 1] = x, y
+            return true
+        end
+
+        local z = toIndex (value.Z)
+        if z == nil then return false end
+
+        into[at], into[at + 1], into[at + 2] = x, y, z
+        return true
+    end
+
+    local function push (from: { number }, at: number): any
+        if not wide then return Vector2.new (fromIndex (from[at]), fromIndex (from[at + 1])) end
+        local x, y = fromIndex (from[at]), fromIndex (from[at + 1])
+        return Vector3.new (x, y, fromIndex (from[at + 2]))
+    end
+
+    return { leaves = leaves, pull = pull, push = push }
+end
+
+-- A direction as the two the octahedral fold keeps, which is `vec3.unit` and nothing else.
+local function pointing (of: Grid.Grid): Fold
+    local mapping = Rotation.octahedral (of)
+    local plane, sphere = mapping.plane, mapping.sphere
+
+    local function pull (value: any, into: { number }, at: number): boolean
+        if typeof (value) ~= VECTOR then return false end
+
+        local u, v = plane (value.X, value.Y, value.Z)
+        if u == nil or v == nil then return false end
+
+        into[at], into[at + 1] = u, v
+        return true
+    end
+
+    local function push (from: { number }, at: number): any
+        return Vector3.new (sphere (from[at], from[at + 1]))
+    end
+
+    return { leaves = { of, of }, pull = pull, push = push }
+end
+
+--[[
+    A direction and how far it reaches, the one form whose leaves are two grids. The length is
+    worked out and never read off the value, so nothing in this file asks a datatype for anything
+    but its components.
+]]
+local function reaching (way: Grid.Grid, far: Grid.Grid): Fold
+    local mapping = Rotation.octahedral (way)
+    local plane, sphere = mapping.plane, mapping.sphere
+    local toIndex, fromIndex = far.toIndex, far.fromIndex
+
+    --[[
+        Where a vector of no length points, which is nowhere and has to be somewhere. The fold
+        divides by the sum of the magnitudes, so a zero would reach the grid as no place at all.
+        The middle of the square is what it takes, which multiplies back out to the zero it was.
+    ]]
+    local centre = way.toIndex (0) :: number
+
+    local function pull (value: any, into: { number }, at: number): boolean
+        if typeof (value) ~= VECTOR then return false end
+
+        local x, y, z = value.X, value.Y, value.Z
+        local length = toIndex (math.sqrt (x * x + y * y + z * z))
+        if length == nil then return false end
+
+        --[[
+            A vector whose length comes to none, which is every vector shorter than half a step and
+            not only the one that arrived as a zero.
+        ]]
+        if fromIndex (length) == 0 then
+            into[at], into[at + 1], into[at + 2] = centre, centre, length
+            return true
+        end
+
+        local u, v = plane (x, y, z)
+        if u == nil or v == nil then return false end
+
+        into[at], into[at + 1], into[at + 2] = u, v, length
+        return true
+    end
+
+    local function push (from: { number }, at: number): any
+        local x, y, z = sphere (from[at], from[at + 1])
+        local length = fromIndex (from[at + 2])
+
+        return Vector3.new (x * length, y * length, z * length)
+    end
+
+    return { leaves = { way, way, far }, pull = pull, push = push }
+end
+
+-- A frame that turns about nothing, which occupies no leaves at all.
+local function still (): Fold
+    local function pull (): boolean return true end
+    local function push (): any return CFrame.identity end
+
+    return { leaves = {}, pull = pull, push = push }
+end
+
+-- A frame as the one number every rotation form here comes back through, which is a quaternion.
+local function turned (leaves: { Grid.Grid }, parts: any, whole: any, reach: number): Fold
+    local function pull (value: any, into: { number }, at: number): boolean
+        if typeof (value) ~= FRAME then return false end
+
+        local first, second, third, fourth = parts (value:GetComponents ())
+        if first == nil then return false end
+
+        into[at] = first :: number
+        if reach == 1 then return true end
+
+        if second == nil then return false end
+        into[at + 1] = second :: number
+        if reach == 2 then return true end
+
+        if third == nil or fourth == nil then return false end
+        into[at + 2], into[at + LAST] = third :: number, fourth :: number
+        return true
+    end
+
+    local function push (from: { number }, at: number): any
+        local x, y, z, w = whole (from[at], from[at + 1], from[at + 2], from[at + LAST])
+        return CFrame.new (0, 0, 0, x, y, z, w)
+    end
+
+    return { leaves = leaves, pull = pull, push = push }
+end
+
+-- The three a packed colour spends its sixteen bits on, red first and least.
+local function packed (): Fold
+    local red, green, blue = Grid.channel (RED), Grid.channel (GREEN), Grid.channel (BLUE)
+
+    local function pull (value: any, into: { number }, at: number): boolean
+        if typeof (value) ~= COLOUR then return false end
+
+        local r, g, b = red.toIndex (value.R), green.toIndex (value.G), blue.toIndex (value.B)
+        if r == nil or g == nil or b == nil then return false end
+
+        into[at], into[at + 1], into[at + 2] = r, g, b
+        return true
+    end
+
+    local function push (from: { number }, at: number): any
+        return Color3.new (
+            red.fromIndex (from[at]),
+            green.fromIndex (from[at + 1]),
+            blue.fromIndex (from[at + 2])
+        )
+    end
+
+    return { leaves = { red, green, blue }, pull = pull, push = push }
+end
+
+-- One of a list of colours, as where it sits in the list.
+local function chosen (colors: { Color3 }): Fold
+    local reach = #colors
+    local of = Grid.index (reach)
+
+    local index: { [string]: number } = {}
+    for place, one in colors do
+        index[`{one.R},{one.G},{one.B}`] = place - 1
+    end
+
+    local function pull (value: any, into: { number }, at: number): boolean
+        if typeof (value) ~= COLOUR then return false end
+
+        local held = index[`{value.R},{value.G},{value.B}`]
+        if held == nil then return false end
+
+        into[at] = held
+        return true
+    end
+
+    local function push (from: { number }, at: number): any return colors[from[at] + 1] end
+
+    return { leaves = { of }, pull = pull, push = push }
+end
+
+-- Public --------------------------------------------------------------
+
+-- Which fold a declaration is, or nothing where it is no region field at all.
+function Folds.fold (of: Base.Cell): Fold?
+    local kind, params = of.kind, of.params
+    local form = params.form
+
+    if kind == "vec2" or kind == "vec3" then
+        local children = of.children
+        local component = if children == nil then nil else children.component
+
+        if form == "unit" then return pointing (Grid.plane (params.step :: number)) end
+        if form == "bounded" then
+            local max, step = params.max :: number, params.step :: number
+            return reaching (Grid.of (-1, 1, step / max), Grid.of (0, max, step))
+        end
+
+        if component == nil then return nil end
+
+        local single = Joins.grid (component)
+        if single == nil then return nil end
+
+        return spread (single, kind == "vec3")
+    end
+
+    if kind == "rotation" then
+        if form == "none" then return still () end
+
+        local step = params.step :: number
+        if form == "axis" then
+            local axis = params.axis :: Vector3
+            local grid = Grid.of (0, Scalars.TURN - step, step, true)
+            local mapping = Rotation.axial (grid, axis.X, axis.Y, axis.Z)
+
+            return turned ({ grid }, mapping.parts, mapping.whole, 1)
+        end
+
+        if form == "direction" then
+            local grid = Grid.plane (step)
+            local mapping = Rotation.facing (grid)
+
+            return turned ({ grid, grid }, mapping.parts, mapping.whole, 2)
+        end
+
+        local chord = Grid.chord (step)
+        local mapping = Rotation.smallest (chord)
+
+        return turned (
+            { Grid.index (CORNERS), chord, chord, chord },
+            mapping.parts,
+            mapping.whole,
+            4
+        )
+    end
+
+    if kind ~= "color3" then return nil end
+
+    if form == "rgb565" then return packed () end
+    if form == "palette" then return chosen (params.colors :: { Color3 }) end
+
+    return nil
+end
+
+-- A declaration, at the leaf it starts on, as the field it becomes.
+function Folds.of (of: Base.Cell, tag: Ir.Tag, at: number, key: string?, nest: number?): Field?
+    local held = Folds.fold (of)
+    if held == nil then return nil end
+
+    return {
+        leaves = held.leaves,
+        join = {
+            at = at,
+            count = #held.leaves,
+            key = key,
+            nest = nest,
+            tag = tag,
+            pull = held.pull,
+            push = held.push,
+        },
+    }
+end
+
+return table.freeze (Folds)