Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / model.lucb

## Owned document records and authoring operations. No serialization or external I/O.
import interop
from luce_std import math
import memory
from animation import Property, Sample, insert_sample, resolve_property
from collections.topology import Topology
from pattern import matches
from path import element_path, is_descendant, parent_path, require_element, require_slot, slot_name, valid_path
from storage import copy_list, copy_names, copy_pairs, find_pair, remove_pair, Blob, Buffer, List, Pair, add_name, close_names, copied, less, own_blob, pair, set_pair, sort_pairs, text_copy
from types import DType, HandleType, Interpolation, invalid, limit_exceeded, missing
from value import Value, ValueData, own_value, scalar_bits
from names import Name

pub struct Element:
    pub var identifier: usize
    pub var path: Buffer
    pub var kind: Buffer
    pub var properties: List[Property]
    pub var metadata: List[Pair]
    pub var override: bool
    pub var removed_properties: List[Buffer]
    pub var removed_metadata: List[Buffer]

    pub func property(name: str) -> usize?:
        for i in 0..<self.properties.count:
            if self.properties.items[i].name.view() == name:
                return i
        return none

    pub func copy() -> Element!:
        var output = Element(identifier = self.identifier, override = self.override)
        errdefer output.close()
        output.path = try self.path.copy()
        output.kind = try self.kind.copy()
        output.metadata = try copy_pairs(&self.metadata)
        output.removed_properties = try copy_names(&self.removed_properties)
        output.removed_metadata = try copy_names(&self.removed_metadata)
        try output.properties.reserve(self.properties.count)
        for prop in self.properties.span():
            try output.properties.push(try prop.copy())
        return output

    pub func put_property(prop: const Property*) -> !:
        var owned = try prop.copy()
        errdefer owned.close()
        if let index = self.property(prop.name.view()):
            self.properties.items[index].close()
            self.properties.items[index] = owned
        else:
            try self.properties.push(owned)
            var i = self.properties.count - 1
            while i > 0 and less(self.properties.items[i].name.view(), self.properties.items[i - 1].name.view()):
                let prior = self.properties.items[i - 1]
                self.properties.items[i - 1] = self.properties.items[i]
                self.properties.items[i] = prior
                i -= 1

    pub func remove_property(name: str):
        if let index = self.property(name):
            self.properties.items[index].close()
            self.properties.remove(index)

    pub func close():
        self.path.close()
        self.kind.close()
        for i in 0..<self.properties.count:
            self.properties.items[i].close()
        self.properties.close()
        for i in 0..<self.metadata.count:
            self.metadata.items[i].close()
        self.metadata.close()
        close_names(&self.removed_properties)
        close_names(&self.removed_metadata)

pub struct Reorder:
    pub var parent: Buffer
    pub var children: List[Buffer]

    pub func close():
        self.parent.close()
        close_names(&self.children)

pub struct Asset:
    pub var path: Buffer
    pub var mime: Buffer
    pub var bytes: Buffer

    pub func close():
        self.path.close()
        self.mime.close()
        self.bytes.close()

pub struct DocumentData:
    pub var references: @u64
    pub var elements: List[Element]
    var topology: Topology
    # Connection key is target, value is source, sorted by target.
    pub var connections: List[Pair]
    pub var deletions: List[Buffer]
    pub var disconnections: List[Buffer]
    pub var reorders: List[Reorder]
    # Wildcard key is source, value is target specification.
    pub var globs: List[Pair]
    pub var assets: List[Asset]

    pub func init():
        return

    pub func copy() -> DocumentData!:
        var output = DocumentData()
        errdefer output.close()
        output.references.store(1, .relaxed)
        output.topology.last_id = self.topology.last_id
        try output.elements.reserve(self.elements.count)
        for element in self.elements.span():
            try output.insert_copy(&element)
        output.connections = try copy_pairs(&self.connections)
        output.globs = try copy_pairs(&self.globs)
        output.deletions = try copy_names(&self.deletions)
        output.disconnections = try copy_names(&self.disconnections)
        for order in self.reorders.span():
            var children: List[str]
            defer children.close()
            for child in order.children.span():
                try children.push(child.view())
            try output.reorder(order.parent.view(), children.span())
        for asset in self.assets.span():
            try output.set_asset(asset.path.view(), asset.bytes.bytes(), asset.mime.view())
        return output

    pub func insert_copy(element: const Element*) -> !:
        var owned = try element.copy()
        errdefer owned.close()
        if let index = self.find(element.path.view()):
            owned.identifier = self.elements.items[index].identifier
            self.elements.items[index].close()
            self.elements.items[index] = owned
        else:
            try self.elements.reserve(self.elements.count + 1)
            owned.identifier = try self.topology.append(owned.path.view(), owned.identifier, self.elements.count)
            try self.elements.push(owned)

    pub func has_property(path: str, name: str) -> bool:
        let index = self.find(path) else return false
        return self.elements.items[index].property(name) != none

    pub func remove_property(path: str, name: str) -> !:
        self.elements.items[try self.require(path)].remove_property(name)

    pub func remove_metadata(path: str, key: str) -> !:
        remove_pair(&self.elements.items[try self.require(path)].metadata, key)

    pub func has_metadata(path: str, key: str) -> bool:
        let index = self.find(path) else return false
        return find_pair(&self.elements.items[index].metadata, key) != none

    pub func metadata_count(path: str) -> usize!:
        return self.elements.items[try self.require(path)].metadata.count

    pub func metadata_name(path: str, index: usize) -> str!:
        let element = &self.elements.items[try self.require(path)]
        if index >= element.metadata.count:
            error(invalid, "Prism metadata index is out of bounds")
        return element.metadata.items[index].key.view()

    pub func set_type(path: str, name: str) -> !:
        let index = try self.require(path)
        let replacement = try text_copy(name)
        self.elements.items[index].kind.close()
        self.elements.items[index].kind = replacement

    pub func children(parent: str) -> List[str]!:
        var output: List[str]
        errdefer output.close()
        for index in self.topology.children(parent):
            try output.push(self.elements.items[index].path.view())
        return output

    pub func find(path: str) -> usize?:
        return self.topology.find(path)

    pub func element_id(path: str) -> usize?:
        let index = self.find(element_path(path)) else return none
        return self.elements.items[index].identifier

    pub func path_for_id(identifier: usize) -> str?:
        let index = self.topology.by_id(identifier) else return none
        return self.elements.items[index].path.view()

    pub func child_count(parent: str) -> usize:
        return self.topology.children(parent).length

    pub func child_at(parent: str, index: usize) -> str?:
        let children = self.topology.children(parent)
        return self.elements.items[children[index]].path.view() if index < children.length else none

    pub func clear_elements():
        for i in 0..<self.elements.count:
            self.elements.items[i].close()
        self.elements.close()
        self.topology.close()

    pub func require(path: str) -> usize!:
        return self.find(path) else error(missing, "Prism element does not exist")

    pub func contains(path: str) -> bool:
        return self.find(path) != none

    pub func element_count() -> usize:
        return self.elements.count

    pub func path_at(index: usize) -> str!:
        if index >= self.elements.count:
            error(invalid, "Prism element index is out of bounds")
        return self.elements.items[index].path.view()

    pub func type_at(path: str) -> str!:
        return self.elements.items[try self.require(path)].kind.view()

    pub func add(path: str, type_name: str, override: bool = false) -> !:
        try require_element(path)
        if self.contains(path):
            error(invalid, "duplicate Prism element path")
        let parent = parent_path(path)
        if parent != "/" and not self.contains(parent):
            error(missing, "add the Prism parent before its child")
        try self.insert(path, type_name, override)

    pub func insert(path: str, type_name: str, override: bool = false) -> !:
        try require_element(path)
        if self.contains(path):
            error(invalid, "duplicate Prism element path")
        var element: Element
        errdefer element.close()
        element.path = try text_copy(path)
        element.kind = try text_copy(type_name)
        element.override = override
        try self.elements.reserve(self.elements.count + 1)
        element.identifier = try self.topology.append(path, 0, self.elements.count)
        try self.elements.push(element)

    pub func put_value(path: str, name: str, value: ValueData, type_name: str = "") -> !:
        var owned = value
        errdefer owned.close()
        let index = try self.require(path)
        var label = try Name.of(type_name)
        errdefer label.close()
        let element = &self.elements.items[index]
        if let position = element.property(name):
            let prop = &element.properties.items[position]
            prop.value.close()
            prop.type_name.close()
            prop.value = owned
            prop.type_name = label
            return
        var key = try Name.of(name)
        errdefer key.close()
        try element.properties.push(Property(name = key, value = owned, type_name = label))
        var position = element.properties.count - 1
        while position > 0 and less(element.properties.items[position].name.view(), element.properties.items[position - 1].name.view()):
            let previous = element.properties.items[position - 1]
            element.properties.items[position - 1] = element.properties.items[position]
            element.properties.items[position] = previous
            position -= 1

    ## Insert a deep snapshot. Later edits or closing Value never change the document.
    pub func set(path: str, name: str, value: interop.Reference[Value], type_name: str = "") -> !:
        let native = try value.get()
        try self.put_value(path, name, try native.view_data().copy(), type_name)

    pub func get(path: str, name: str) -> interop.Reference[Value]!:
        let element = &self.elements.items[try self.require(path)]
        let index = element.property(name) else error(missing, "Prism property does not exist")
        return try own_value(try element.properties.items[index].value.copy())

    pub func property_count(path: str) -> usize!:
        return self.elements.items[try self.require(path)].properties.count

    pub func property_name(path: str, index: usize) -> str!:
        let element = &self.elements.items[try self.require(path)]
        if index >= element.properties.count:
            error(invalid, "Prism property index is out of bounds")
        return element.properties.items[index].name.view()

    pub func set_metadata(path: str, key: str, value: str) -> !:
        let element = &self.elements.items[try self.require(path)]
        try set_pair(&element.metadata, key, value)

    pub func metadata(path: str, key: str) -> str!:
        let element = &self.elements.items[try self.require(path)]
        for item in element.metadata.span():
            if item.key.view() == key:
                return item.value.view()
        error(missing, "Prism metadata does not exist")

    pub func connect(source: str, target: str) -> !:
        try require_slot(source)
        try require_slot(target)
        try set_pair(&self.connections, target, source)

    pub func connection_count() -> usize:
        return self.connections.count

    pub func incoming(target: str) -> str?:
        for connection in self.connections.span():
            if connection.key.view() == target:
                return connection.value.view()
        let name = slot_name(target)
        if name.length > 0:
            for glob in self.globs.span():
                if slot_name(glob.value.view()) == name and matches(element_path(glob.value.view()), element_path(target)):
                    return glob.key.view()
        return none

    pub func source(target: str) -> str!:
        return self.incoming(target) else error(missing, "Prism input is not connected")

    pub func disconnect(target: str):
        for i in 0..<self.connections.count:
            if self.connections.items[i].key.view() == target:
                self.connections.items[i].close()
                self.connections.remove(i)
                return

    pub func set_sample(path: str, name: str, time: f64, value: interop.Reference[Value], interpolation: Interpolation = Interpolation.linear) -> !:
        if not math.is_finite(time):
            error(invalid, "Prism keyframe time must be finite")
        let element = &self.elements.items[try self.require(path)]
        let index = element.property(name) else error(missing, "create a default before adding Prism samples")
        let prop = &element.properties.items[index]
        var sample = Sample(time = time, interpolation = interpolation)
        errdefer sample.close()
        sample.value = try (try value.get()).view_data().copy()
        for current in prop.samples.span():
            if current.time == time:
                sample.handle = current.handle
                sample.left = try copy_list(&current.left)
                sample.right = try copy_list(&current.right)
                break
        try insert_sample(prop, sample)

    pub func set_handles(path: str, name: str, time: f64, kind: HandleType, left: const f64[], right: const f64[]) -> !:
        if left.length % 2 != 0 or right.length % 2 != 0:
            error(invalid, "Prism handles contain (time, value) pairs")
        let element = &self.elements.items[try self.require(path)]
        let position = element.property(name) else error(missing, "Prism property does not exist")
        let prop = &element.properties.items[position]
        for i in 0..<prop.samples.count:
            if prop.samples.items[i].time == time:
                var l: List[f64]
                errdefer l.close()
                var r: List[f64]
                errdefer r.close()
                for value in left:
                    if not math.is_finite(value):
                        error(invalid, "Prism handle must be finite")
                    try l.push(value)
                for value in right:
                    if not math.is_finite(value):
                        error(invalid, "Prism handle must be finite")
                    try r.push(value)
                let sample = &prop.samples.items[i]
                sample.left.close()
                sample.right.close()
                sample.left = l
                sample.right = r
                sample.handle = (u8)kind
                return

    pub func remove_sample(path: str, name: str, time: f64) -> !:
        let element = &self.elements.items[try self.require(path)]
        let index = element.property(name) else return
        let prop = &element.properties.items[index]
        for i in 0..<prop.samples.count:
            if prop.samples.items[i].time == time:
                prop.samples.items[i].close()
                prop.samples.remove(i)
                return

    pub func sample_count(path: str, name: str) -> usize!:
        let element = &self.elements.items[try self.require(path)]
        let index = element.property(name) else error(missing, "Prism property does not exist")
        return element.properties.items[index].samples.count

    pub func resolve(path: str, name: str, time: f64 = 0.0) -> interop.Reference[Value]!:
        if not math.is_finite(time):
            error(invalid, "Prism evaluation time must be finite")
        let element = &self.elements.items[try self.require(path)]
        let index = element.property(name) else error(missing, "Prism property does not exist")
        return try own_value(try resolve_property(&element.properties.items[index], time))

    ## Attribute evaluation follows the authored incoming source, as in C++.
    ## Computed DAGs use Evaluator; an absent source resolves to float32 zero.
    pub func eval(slot: str, time: f64 = 0.0) -> interop.Reference[Value]!:
        if not math.is_finite(time):
            error(invalid, "Prism evaluation time must be finite")
        if not valid_path(slot) or slot_name(slot).length == 0:
            return try own_value(try scalar_bits(DType.float32, 0))
        let current = self.incoming(slot) else slot
        if not self.has_property(element_path(current), slot_name(current)):
            return try own_value(try scalar_bits(DType.float32, 0))
        return try self.resolve(element_path(current), slot_name(current), time)

    pub func mark_deleted(path: str) -> !:
        try require_element(path)
        try add_name(&self.deletions, path)

    pub func mark_disconnected(target: str) -> !:
        try require_slot(target)
        try add_name(&self.disconnections, target)

    pub func mark_unset(path: str, name: str, metadata: bool = false) -> !:
        let element = &self.elements.items[try self.require(path)]
        if metadata:
            try add_name(&element.removed_metadata, name)
        else:
            try add_name(&element.removed_properties, name)

    pub func reorder(parent: str, children: const str[]) -> !:
        if not valid_path(parent) or element_path(parent) != parent:
            error(invalid, "invalid Prism reorder parent")
        var order: Reorder
        errdefer order.close()
        order.parent = try text_copy(parent)
        for child in children:
            try require_element(child)
            if parent_path(child) != parent:
                error(invalid, "Prism reorder entries must be direct children")
            for existing in order.children.span():
                if existing.view() == child:
                    error(invalid, "duplicate Prism reorder child")
            var copy = try text_copy(child)
            order.children.push(copy) catch failure:
                copy.close()
                error(failure.code, failure.message)
        for i in 0..<self.reorders.count:
            if self.reorders.items[i].parent.view() == parent:
                self.reorders.items[i].close()
                self.reorders.items[i] = order
                return
        try self.reorders.push(order)
        sort_reorders(&self.reorders)

    pub func connect_pattern(source: str, target_pattern: str) -> !:
        try require_slot(source)
        if target_pattern.length == 0 or target_pattern.bytes[0] != '/':
            error(invalid, "Prism wildcard target must be absolute")
        for item in self.globs.span():
            if item.key.view() == source and item.value.view() == target_pattern:
                return
        var item = try pair(source, target_pattern)
        errdefer item.close()
        try self.globs.push(item)

    pub func set_asset(key: str, bytes: const u8[], mime: str = "application/octet-stream") -> !:
        if not valid_path(key):
            error(invalid, "invalid Prism asset path")
        let path = element_path(key)
        var asset: Asset
        errdefer asset.close()
        asset.path = try text_copy(path)
        asset.mime = try text_copy(mime)
        asset.bytes = try copied(bytes)
        for i in 0..<self.assets.count:
            if self.assets.items[i].path.view() == path:
                self.assets.items[i].close()
                self.assets.items[i] = asset
                return
        try self.assets.push(asset)
        var i = self.assets.count - 1
        while i > 0 and less(self.assets.items[i].path.view(), self.assets.items[i - 1].path.view()):
            let previous = self.assets.items[i - 1]
            self.assets.items[i - 1] = self.assets.items[i]
            self.assets.items[i] = previous
            i -= 1

    ## Rename/reparent a subtree. All allocations finish before any path changes.
    pub func rename(path: str, destination: str) -> !:
        try require_element(path)
        try require_element(destination)
        _ = try self.require(path)
        if path == destination:
            return
        if is_descendant(destination, path) or self.contains(destination):
            error(invalid, "Prism rename would collide or create a hierarchy cycle")
        # Asset and layer paths may exist without local elements. Do not merge
        # those records accidentally when moving a populated subtree onto them.
        for asset in self.assets.span():
            if is_descendant(asset.path.view(), destination) and not is_descendant(asset.path.view(), path):
                error(invalid, "Prism rename collides with an asset path")
        for connection in self.connections.span():
            if is_descendant(connection.key.view(), destination) and not is_descendant(connection.key.view(), path):
                error(invalid, "Prism rename collides with a connection target")
        for order in self.reorders.span():
            if is_descendant(order.parent.view(), destination) and not is_descendant(order.parent.view(), path):
                error(invalid, "Prism rename collides with a reorder opinion")
        for deletion in self.deletions.span():
            if is_descendant(deletion.view(), destination) and not is_descendant(deletion.view(), path):
                error(invalid, "Prism rename collides with a deletion opinion")
        for deletion in self.disconnections.span():
            if is_descendant(deletion.view(), destination) and not is_descendant(deletion.view(), path):
                error(invalid, "Prism rename collides with a disconnect opinion")
        var edits: List[PathEdit]
        defer close_edits(&edits)
        for i in 0..<self.elements.count:
            try plan_path(&edits, &self.elements.items[i].path, path, destination)
        for i in 0..<self.connections.count:
            try plan_path(&edits, &self.connections.items[i].key, path, destination)
            try plan_path(&edits, &self.connections.items[i].value, path, destination)
        for i in 0..<self.assets.count:
            try plan_path(&edits, &self.assets.items[i].path, path, destination)
        for i in 0..<self.globs.count:
            try plan_path(&edits, &self.globs.items[i].key, path, destination)
            try plan_path(&edits, &self.globs.items[i].value, path, destination)
        for i in 0..<self.reorders.count:
            try plan_path(&edits, &self.reorders.items[i].parent, path, destination)
            for j in 0..<self.reorders.items[i].children.count:
                try plan_path(&edits, &self.reorders.items[i].children.items[j], path, destination)
        for i in 0..<self.deletions.count:
            try plan_path(&edits, &self.deletions.items[i], path, destination)
        for i in 0..<self.disconnections.count:
            try plan_path(&edits, &self.disconnections.items[i], path, destination)
        var topology = Topology(last_id = self.topology.last_id)
        defer topology.close()
        for i in 0..<self.elements.count:
            let element = &self.elements.items[i]
            var rewritten: Buffer
            defer rewritten.close()
            var name = element.path.view()
            if is_descendant(name, path):
                try rewritten.text(destination)
                try rewritten.put(name.bytes[path.length..])
                name = rewritten.view()
            _ = try topology.append(name, element.identifier, i)
        for i in 0..<edits.count:
            let edit = &edits.items[i]
            edit.target.close()
            *edit.target = edit.replacement
            edit.replacement = Buffer()
        self.topology.close()
        self.topology = topology
        topology = Topology()
        sort_pairs(&self.connections)
        sort_names(&self.deletions)
        sort_names(&self.disconnections)
        sort_assets(&self.assets)
        sort_reorders(&self.reorders)
        # A moved child is no longer part of the old parent's reorder opinion.
        for i in 0..<self.reorders.count:
            let order = &self.reorders.items[i]
            var j = order.children.count
            while j > 0:
                j -= 1
                if parent_path(order.children.items[j].view()) != order.parent.view():
                    order.children.items[j].close()
                    order.children.remove(j)

    ## Remove content, incident wires, assets and affected wildcard/reorder entries.
    pub func remove(path: str) -> !:
        try require_element(path)
        _ = try self.require(path)
        var owned_path = try text_copy(path)
        defer owned_path.close()
        let root = owned_path.view()
        var topology = Topology(last_id = self.topology.last_id)
        defer topology.close()
        var kept: usize = 0
        for element in self.elements.span():
            if not is_descendant(element.path.view(), root):
                _ = try topology.append(element.path.view(), element.identifier, kept)
                kept += 1
        kept = 0
        for index in 0..<self.elements.count:
            if is_descendant(self.elements.items[index].path.view(), root):
                self.elements.items[index].close()
            else:
                self.elements.items[kept] = self.elements.items[index]
                kept += 1
        self.elements.count = kept
        self.topology.close()
        self.topology = topology
        topology = Topology()
        var i = self.connections.count
        while i > 0:
            i -= 1
            if is_descendant(self.connections.items[i].key.view(), root) or is_descendant(self.connections.items[i].value.view(), root):
                self.connections.items[i].close()
                self.connections.remove(i)
        i = self.assets.count
        while i > 0:
            i -= 1
            if is_descendant(self.assets.items[i].path.view(), root):
                self.assets.items[i].close()
                self.assets.remove(i)
        i = self.globs.count
        while i > 0:
            i -= 1
            if is_descendant(self.globs.items[i].key.view(), root) or is_descendant(self.globs.items[i].value.view(), root):
                self.globs.items[i].close()
                self.globs.remove(i)
        i = self.reorders.count
        while i > 0:
            i -= 1
            let order = &self.reorders.items[i]
            if is_descendant(order.parent.view(), root):
                order.close()
                self.reorders.remove(i)
            else:
                var j = order.children.count
                while j > 0:
                    j -= 1
                    if is_descendant(order.children.items[j].view(), root):
                        order.children.items[j].close()
                        order.children.remove(j)

    pub func asset_count() -> usize:
        return self.assets.count

    pub func remove_asset(key: str):
        if not valid_path(key):
            return
        let path = element_path(key)
        for i in 0..<self.assets.count:
            if self.assets.items[i].path.view() == path:
                self.assets.items[i].close()
                self.assets.remove(i)
                return

    pub func asset(path: str) -> interop.Reference[Blob]!:
        for asset in self.assets.span():
            if asset.path.view() == element_path(path):
                return try own_blob(try asset.bytes.copy())
        error(missing, "Prism asset does not exist")

    pub func asset_mime(path: str) -> str!:
        for asset in self.assets.span():
            if asset.path.view() == element_path(path):
                return asset.mime.view()
        error(missing, "Prism asset does not exist")

    pub func close():
        for i in 0..<self.elements.count:
            self.elements.items[i].close()
        self.elements.close()
        self.topology.close()
        for i in 0..<self.connections.count:
            self.connections.items[i].close()
        self.connections.close()
        close_names(&self.deletions)
        close_names(&self.disconnections)
        for i in 0..<self.reorders.count:
            self.reorders.items[i].close()
        self.reorders.close()
        for i in 0..<self.globs.count:
            self.globs.items[i].close()
        self.globs.close()
        for i in 0..<self.assets.count:
            self.assets.items[i].close()
        self.assets.close()

pub func close_elements(elements: List[Element]*):
    for i in 0..<elements.count:
        elements.items[i].close()
    elements.close()

pub func hold_data(data: DocumentData*):
    _ = data.references.add(1, .relaxed)

pub func drop_data(data: DocumentData*):
    if data.references.sub(1, .acq_rel) == 1:
        data.close()
        free(data) in memory.heap

pub func own_data(data: DocumentData) -> DocumentData*!:
    var owned = data
    let heap = new DocumentData() in memory.heap catch failure:
        error(failure.code, failure.message)
    heap.close()
    heap[0] = owned
    owned = DocumentData()
    heap.references.store(1, .relaxed)
    return heap

pub struct PathEdit:
    pub var target: Buffer*
    pub var replacement: Buffer

pub func close_edits(edits: List[PathEdit]*):
    for i in 0..<edits.count:
        edits.items[i].replacement.close()
    edits.close()

pub func plan_path(edits: List[PathEdit]*, target: Buffer*, old: str, replacement: str) -> !:
    if not is_descendant(target.view(), old):
        return
    var text: Buffer
    errdefer text.close()
    try text.text(replacement)
    try text.put(target.bytes()[old.length..])
    if text.used > 4096:
        error(limit_exceeded, "renamed Prism path exceeds 4096 bytes")
    try edits.push(PathEdit(target = target, replacement = text))

pub func sort_names(names: List[Buffer]*):
    for end in 1..<names.count:
        var i = end
        while i > 0 and less(names.items[i].view(), names.items[i - 1].view()):
            let previous = names.items[i - 1]
            names.items[i - 1] = names.items[i]
            names.items[i] = previous
            i -= 1

pub func sort_assets(assets: List[Asset]*):
    for end in 1..<assets.count:
        var i = end
        while i > 0 and less(assets.items[i].path.view(), assets.items[i - 1].path.view()):
            let previous = assets.items[i - 1]
            assets.items[i - 1] = assets.items[i]
            assets.items[i] = previous
            i -= 1

pub func sort_reorders(orders: List[Reorder]*):
    for end in 1..<orders.count:
        var i = end
        while i > 0 and less(orders.items[i].parent.view(), orders.items[i - 1].parent.view()):
            let previous = orders.items[i - 1]
            orders.items[i - 1] = orders.items[i]
            orders.items[i] = previous
            i -= 1