Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / persist.lucb

## Durable layer blobs in a Prism-owned WAL. RAM Store.memory() does not open this.
import memory
import composition.delta
import extents
import file_access as file_io
import tables
import wal.engine as wal
import wal.tree as wal_tree
import wal.schema as wal_schema
from animation import Sample
from model import DocumentData
from serialization.binary import write_binary
from serialization.dispatch import read_document
from serialization.package import write_package
from storage import Buffer, List, Reader, close_names, copied, text_copy
from types import Interpolation, invalid, limit_exceeded, unsupported, busy, closed, conflict, timed_out
from value import ValueData, Locator, read_value, write_value
import wal.bytes as wal_bytes

pub let schema_key: str = "prism/encoding"
pub let schema_application: str = "luce-prism"
pub let payload_budget: usize = 16777184
pub let max_value: usize = 1048576
let layer_version: u8 = 1

func prism_wal_code(code: ErrorCode) -> ErrorCode:
    if code == wal_bytes.busy:
        return busy
    if code == wal_bytes.limit:
        return limit_exceeded
    if code == wal_bytes.closed:
        return closed
    if code == wal_bytes.conflict:
        return conflict
    if code == wal_bytes.timed_out:
        return timed_out
    if code == wal_bytes.uncertain:
        return closed
    return invalid

pub struct Journal:
    var store: wal.Store*?
    var path: Buffer

    pub func init():
        return

pub func close_journal(journal: Journal*):
    if let store = journal.store:
        wal.drop(store)
    journal.store = none
    journal.path.close()
    free(journal) in memory.heap

pub func open_journal(path: str) -> Journal*!:
    let store = wal.open(path) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    let journal = new Journal() in memory.heap catch failure:
        wal.drop(store)
        error(failure.code, failure.message)
    journal.store = store
    journal.path = text_copy(path) catch failure:
        journal.store = none
        wal.drop(store)
        free(journal) in memory.heap
        error(failure.code, failure.message)
    return journal

func journal_store(journal: Journal*) -> wal.Store*!:
    return journal.store else error(invalid, "Prism journal is closed")

pub func journal_path(journal: Journal*) -> str:
    return journal.path.view()

pub func encoded_put(key_length: usize, value_length: usize) -> usize:
    return 9 + key_length + value_length

func put_decimal(out: Buffer*, value: u64) -> !:
    if value == 0:
        try out.byte((u8)48)
        return
    var digits: u8[20]
    var n = value
    var i: usize = 20
    while n > 0:
        i -= 1
        digits[i] = (u8)(48 + n % 10)
        n = n // 10
    try out.put(digits[i..])

func parse_u64(text: str) -> u64?:
    if text.length == 0:
        return none
    var value: u64 = 0
    for byte in text.bytes:
        if byte < '0' or byte > '9':
            return none
        let next = value *? 10 else return none
        value = next + (u64)(byte - '0')
    return value

pub func unbaked_key(identity: str, generation: u64) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text("u/")
    try out.text(identity)
    try out.byte((u8)'/')
    var digits: u8[20]
    var n = generation
    var i: usize = 20
    while i > 0:
        i -= 1
        digits[i] = (u8)(48 + n % 10)
        n = n // 10
    try out.put(digits)
    return out

func unbaked_count_key(identity: str, generation: u64) -> Buffer!:
    var out = try unbaked_key(identity, generation)
    errdefer out.close()
    try out.text("/#")
    return out

func unbaked_chunk_key(identity: str, generation: u64, index: usize) -> Buffer!:
    var out = try unbaked_key(identity, generation)
    errdefer out.close()
    try out.byte((u8)'/')
    try put_decimal(&out, (u64)index)
    return out

func snap_through_key(identity: str) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text("s/")
    try out.text(identity)
    try out.text("/through")
    return out

func snap_kind_key(identity: str) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text("s/")
    try out.text(identity)
    try out.text("/kind")
    return out

func snap_file_key(identity: str) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text("s/")
    try out.text(identity)
    try out.text("/file")
    return out

func snap_count_key(identity: str) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text("s/")
    try out.text(identity)
    try out.text("/#")
    return out

func snap_chunk_key(identity: str, index: usize) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text("s/")
    try out.text(identity)
    try out.byte((u8)'/')
    try put_decimal(&out, (u64)index)
    return out

pub func journal_bytes_for_layer(identity: str, generation: u64, layer_bytes: usize) -> usize!:
    var key = try unbaked_key(identity, generation)
    defer key.close()
    if layer_bytes <= max_value:
        return encoded_put(key.used, layer_bytes)
    var count_key = try unbaked_count_key(identity, generation)
    defer count_key.close()
    var remaining = layer_bytes
    var index: usize = 0
    var total = encoded_put(count_key.used, 1)
    while remaining > 0:
        let chunk = max_value if remaining > max_value else remaining
        var part = try unbaked_chunk_key(identity, generation, index)
        defer part.close()
        total += encoded_put(part.used, chunk)
        remaining -= chunk
        index += 1
        if total > payload_budget:
            return total
    return total

pub func encode_layer(layer: const delta.Layer*) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.put(b"PRLY")
    try out.byte(layer_version)
    try out.uint((u64)layer.items.count, 4)
    for entry in layer.items.span():
        try out.sized(entry.key.path.view())
        try out.sized(entry.key.name.view())
        try out.byte((u8)entry.key.cell)
        var flags: u8 = 0
        if entry.op.deleted:
            flags |= 1
        if entry.op.override:
            flags |= 2
        # A payload in an extent is journalled as a reference (see extents).
        if entry.op.value.locator != none:
            flags |= 4
        try out.byte(flags)
        try out.uint((u64)entry.op.identifier, 8)
        try out.sized(entry.op.type_name.view())
        try out.sized(entry.op.text.view())
        var encoded_value: Buffer
        if (flags & 4) != 0:
            try extents.write_stub(&encoded_value, &entry.op.value)
        else:
            try write_value(&encoded_value, &entry.op.value)
        try out.uint((u64)encoded_value.used, 4)
        try out.put(encoded_value.bytes())
        encoded_value.close()
        try out.uint((u64)entry.op.children.count, 4)
        for child in entry.op.children.span():
            try out.sized(child.view())
        try out.uint((u64)entry.op.samples.count, 4)
        for sample in entry.op.samples.span():
            try out.real(sample.time)
            var encoded_sample: Buffer
            try write_value(&encoded_sample, &sample.value)
            try out.uint((u64)encoded_sample.used, 4)
            try out.put(encoded_sample.bytes())
            encoded_sample.close()
            try out.uint((u64)sample.interpolation, 1)
            try out.byte(sample.handle)
            try out.uint((u64)sample.left.count, 4)
            for value in sample.left.span():
                try out.real(value)
            try out.uint((u64)sample.right.count, 4)
            for value in sample.right.span():
                try out.real(value)
    return out

func read_sized(reader: Reader*) -> Buffer!:
    let text = try reader.text()
    return try text_copy(text)

pub func decode_layer(bytes: const u8[]) -> delta.Layer!:
    var reader = Reader(data = bytes)
    let magic = try reader.take(4)
    if magic.length != 4 or magic[0] != 'P' or magic[1] != 'R' or magic[2] != 'L' or magic[3] != 'Y':
        error(invalid, "invalid Prism layer blob")
    if try reader.uint(1) != (u64)layer_version:
        error(unsupported, "unsupported Prism layer encoding")
    let count = try reader.count(1)
    var layer = delta.Layer()
    errdefer layer.close()
    for i in 0..<count:
        var path = try read_sized(&reader)
        defer path.close()
        var name = try read_sized(&reader)
        defer name.close()
        let cell = (delta.Cell)(u8)try reader.uint(1)
        let flags = (u8)try reader.uint(1)
        var op = delta.Op(deleted = (flags & 1) != 0, override = (flags & 2) != 0)
        errdefer op.close()
        op.identifier = (usize)try reader.uint(8)
        op.type_name = try read_sized(&reader)
        op.text = try read_sized(&reader)
        let value_size = (usize)try reader.uint(4)
        let value_bytes = try reader.take(value_size)
        var value_reader = Reader(data = value_bytes)
        if (flags & 4) != 0:
            op.value = try extents.read_stub(&value_reader)
        else:
            op.value = read_value(&value_reader) catch failure:
                recover ValueData()
        let children = try reader.count(0)
        try op.children.reserve(children)
        for c in 0..<children:
            var child = try read_sized(&reader)
            errdefer child.close()
            try op.children.push(child)
            child = Buffer()
        let samples = try reader.count(0)
        try op.samples.reserve(samples)
        for s in 0..<samples:
            var sample = Sample()
            errdefer sample.close()
            sample.time = try reader.real()
            let sample_size = (usize)try reader.uint(4)
            let sample_bytes = try reader.take(sample_size)
            var sample_reader = Reader(data = sample_bytes)
            sample.value = read_value(&sample_reader) catch failure:
                recover ValueData()
            sample.interpolation = (Interpolation)(u8)try reader.uint(1)
            sample.handle = (u8)try reader.uint(1)
            let left = try reader.count(0)
            try sample.left.reserve(left)
            for n in 0..<left:
                try sample.left.push(try reader.real())
            let right = try reader.count(0)
            try sample.right.reserve(right)
            for n in 0..<right:
                try sample.right.push(try reader.real())
            try op.samples.push(sample)
            sample = Sample()
        try layer.put(path.view(), cell, name.view(), op)
        op = delta.Op()
    if reader.pos != bytes.length:
        error(invalid, "trailing Prism layer blob")
    return layer

func put_chunked(tx: wal.Transaction*, prefix: const Buffer*, payload: const u8[], allow_single: bool = true) -> !:
    if allow_single and payload.length <= max_value:
        try tx.put(prefix.view(), payload)
        return
    var remaining = payload.length
    var index: usize = 0
    var start: usize = 0
    while remaining > 0:
        let chunk = max_value if remaining > max_value else remaining
        var key: Buffer
        defer key.close()
        try key.put(prefix.bytes())
        try key.byte((u8)'/')
        try put_decimal(&key, (u64)index)
        try tx.put(key.view(), payload[start..<start + chunk])
        start += chunk
        remaining -= chunk
        index += 1
    var count_key: Buffer
    defer count_key.close()
    try count_key.put(prefix.bytes())
    try count_key.text("/#")
    var digits: Buffer
    defer digits.close()
    try put_decimal(&digits, (u64)index)
    try tx.put(count_key.view(), digits.bytes())

func snap_copy(snap: wal.View*, key: str) -> Buffer?!:
    let item = (try snap.get(key)) else return none
    return try copied(item.value.span())

func load_chunked(snap: wal.View*, prefix: str) -> Buffer!:
    if let single = try snap_copy(snap, prefix):
        return single
    var count_key: Buffer
    defer count_key.close()
    try count_key.text(prefix)
    try count_key.text("/#")
    var listed = try snap_copy(snap, count_key.view()) else error(invalid, "missing Prism snapshot chunks")
    defer listed.close()
    let count = parse_u64(listed.view()) else error(invalid, "invalid Prism chunk count")
    var out: Buffer
    errdefer out.close()
    var index: u64 = 0
    while index < count:
        var key: Buffer
        defer key.close()
        try key.text(prefix)
        try key.byte((u8)'/')
        try put_decimal(&key, index)
        var chunk = try snap_copy(snap, key.view()) else error(invalid, "missing Prism snapshot chunk")
        defer chunk.close()
        try out.put(chunk.bytes())
        index += 1
    return out

func identity_from_key(key: str) -> str?:
    if key.length < 3:
        return none
    if (str)key.bytes[..<2] != "s/" and (str)key.bytes[..<2] != "u/":
        return none
    var i: usize = 2
    while i < key.length and key.bytes[i] != '/':
        i += 1
    if i == 2:
        return none
    return (str)key.bytes[2..<i]

func has_name(names: const List[Buffer]*, name: str) -> bool:
    for item in names.span():
        if item.view() == name:
            return true
    return false

func collect_identities(snap: wal.View*) -> List[Buffer]!:
    var names: List[Buffer]
    errdefer close_names(&names)
    let records = (i64)wal_tree.count(snap.root)
    var i: i64 = 0
    while i < records:
        if let item = wal_tree.at(snap.root, (usize)i):
            let key = (str)item.key.span()
            if let identity = identity_from_key(key):
                if not has_name(&names, identity):
                    var copy = try text_copy(identity)
                    errdefer copy.close()
                    try names.push(copy)
        i += 1
    return names

func parse_unbaked_gen(key: str, identity: str) -> u64?:
    let prefix_len = 3 + identity.length
    if key.length < prefix_len + 20:
        return none
    if (str)key.bytes[..<2] != "u/":
        return none
    if (str)key.bytes[2..<2 + identity.length] != identity:
        return none
    if key.bytes[2 + identity.length] != '/':
        return none
    let digits = (str)key.bytes[prefix_len..<prefix_len + 20]
    return parse_u64(digits)

func max_complete_gen(snap: wal.View*, identity: str) -> u64?!:
    var highest: u64? = none
    let records = (i64)wal_tree.count(snap.root)
    var i: i64 = 0
    while i < records:
        if let item = wal_tree.at(snap.root, (usize)i):
            let key = (str)item.key.span()
            if let gen = parse_unbaked_gen(key, identity):
                if highest == none or gen > (highest else 0):
                    var marker = try unbaked_key(identity, gen)
                    defer marker.close()
                    var hashed = try unbaked_count_key(identity, gen)
                    defer hashed.close()
                    if try snap.get(marker.view()) != none or try snap.get(hashed.view()) != none:
                        highest = gen
        i += 1
    return highest

func load_unbaked_blob(snap: wal.View*, identity: str, generation: u64) -> Buffer!:
    var key = try unbaked_key(identity, generation)
    defer key.close()
    return try load_chunked(snap, key.view())

## Tables from a snapshot blob: its crate, with the values that live in extents put
## back as stubs.
func decode_snapshot(bytes: const u8[]) -> tables.Tables*!:
    let (crate, places) = try extents.unwrap(bytes)
    var data = DocumentData()
    # adopt_data moves properties out; the rest of the parsed source is released here.
    defer data.close()
    try read_document(crate, &data)
    let owned = try tables.adopt_data(&data)
    errdefer tables.drop_tables(owned)
    try extents.restore(owned, places)
    return owned

## A snapshot blob of `owned`: large payloads no commit wrote go to extents first,
## then the crate carries references to every extent, not the payloads.
func encode_tables(journal: Journal*, identity: str, owned: tables.Tables*, through: u64) -> Buffer!:
    try extents.write_unwritten(journal.path.view(), identity, through, owned)
    var data = try tables.to_data(owned)
    defer data.close()
    var places: Buffer
    defer places.close()
    try extents.strip(&data, &places)
    var crate: Buffer
    defer crate.close()
    if data.assets.count > 0:
        crate = try write_package(&data, false)
    else:
        crate = try write_binary(&data)
    return try extents.wrap(crate.bytes(), &places)

func valid_basename(name: str) -> bool:
    if name.length == 0 or name == "." or name == "..":
        return false
    for byte in name.bytes:
        if byte == '/' or byte == 0:
            return false
    return true

func snap_dir(journal: Journal*) -> Buffer!:
    var out = try journal.path.copy()
    errdefer out.close()
    try out.text(".snap")
    return out

func join_path(dir: str, name: str) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text(dir)
    if dir.length > 0 and dir.bytes[dir.length - 1] != '/':
        try out.byte((u8)'/')
    try out.text(name)
    return out

pub struct LoadedLayer:
    pub var generation: u64
    pub var layer: delta.Layer

    pub func init():
        return

pub struct LoadedIdentity:
    pub var name: Buffer
    pub var generation: u64
    pub var last_id: usize
    pub var tables: tables.Tables*?
    pub var unbaked: List[LoadedLayer]

    pub func init():
        return

pub func close_loaded_identity(item: LoadedIdentity*):
    item.name.close()
    if let owned = item.tables:
        tables.drop_tables(owned)
    item.tables = none
    for i in 0..<item.unbaked.count:
        item.unbaked.items[i].layer.close()
    item.unbaked.close()

pub func close_loaded(items: List[LoadedIdentity]*):
    for i in 0..<items.count:
        close_loaded_identity(&items.items[i])
    items.close()

func max_layer_id(layer: const delta.Layer*) -> usize:
    var highest: usize = 0
    for entry in layer.items.span():
        if entry.op.identifier > highest:
            highest = entry.op.identifier
    return highest

func load_one(snap: wal.View*, journal: Journal*, identity: str) -> LoadedIdentity!:
    var out = LoadedIdentity()
    errdefer close_loaded_identity(&out)
    out.name = try text_copy(identity)
    var through_key = try snap_through_key(identity)
    defer through_key.close()
    var through: u64 = 0
    if let raw_copy = try snap_copy(snap, through_key.view()):
        var raw = raw_copy
        defer raw.close()
        through = parse_u64(raw.view()) else 0
    var kind_key = try snap_kind_key(identity)
    defer kind_key.close()
    if let label_copy = try snap_copy(snap, kind_key.view()):
        var label = label_copy
        defer label.close()
        let text = label.view()
        if text == "file":
            var file_key = try snap_file_key(identity)
            defer file_key.close()
            var listed = try snap_copy(snap, file_key.view()) else error(invalid, "missing Prism snapshot file")
            defer listed.close()
            if not valid_basename(listed.view()):
                error(invalid, "invalid Prism snapshot basename")
            var dir = try snap_dir(journal)
            defer dir.close()
            var path = try join_path(dir.view(), listed.view())
            defer path.close()
            var crate = try file_io.read(path.view())
            defer crate.close()
            out.tables = try decode_snapshot(crate.bytes())
        elif text == "inline":
            var prefix: Buffer
            defer prefix.close()
            try prefix.text("s/")
            try prefix.text(identity)
            var crate = try load_chunked(snap, prefix.view())
            defer crate.close()
            out.tables = try decode_snapshot(crate.bytes())
        else:
            out.tables = try tables.empty_tables()
            through = 0
    else:
        out.tables = try tables.empty_tables()
        through = 0
    let owned_tables = out.tables else error(invalid, "Prism identity tables missing")
    var last = tables.max_identifier(owned_tables)
    var generation = through
    if let high = try max_complete_gen(snap, identity):
        var gen = through + 1
        while gen <= high:
            var blob = try load_unbaked_blob(snap, identity, gen)
            defer blob.close()
            var layer = try decode_layer(blob.bytes())
            errdefer layer.close()
            let layer_id = max_layer_id(&layer)
            if layer_id > last:
                last = layer_id
            var item = LoadedLayer()
            item.generation = gen
            item.layer = layer
            layer = delta.Layer()
            try out.unbaked.push(item)
            generation = gen
            gen += 1
    out.generation = generation
    out.last_id = last
    return out

pub func prepare_schema(journal: Journal*) -> !:
    let store = try journal_store(journal)
    var snap = wal.snapshot(store) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    defer snap.close()
    if wal_tree.count(snap.root) == 0:
        wal_schema.initialize(store, schema_key, schema_application) catch failure:
            error(prism_wal_code(failure.code), failure.message)
        return
    let version = wal_schema.current(snap, schema_key, schema_application) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    let ver = version else error(invalid, "unversioned journal is not a Prism store")
    if ver != 0:
        error(unsupported, "prism/encoding")

pub func load_identities(journal: Journal*) -> List[LoadedIdentity]!:
    let store = try journal_store(journal)
    var snap = wal.snapshot(store) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    defer snap.close()
    var names = try collect_identities(&snap)
    defer close_names(&names)
    var out: List[LoadedIdentity]
    errdefer close_loaded(&out)
    for name in names.span():
        var loaded = try load_one(&snap, journal, name.view())
        out.push(loaded) catch failure:
            close_loaded_identity(&loaded)
            error(failure.code, failure.message)
        loaded = LoadedIdentity()
    return out

pub func append_layer(journal: Journal*, identity: str, generation: u64, layer: delta.Layer*, wait_ms: i64) -> !:
    try extents.externalize(journal.path.view(), identity, generation, layer)
    var blob = try encode_layer(layer)
    defer blob.close()
    let cost = try journal_bytes_for_layer(identity, generation, blob.used)
    if layer.items.count > 65536 or cost > payload_budget:
        error(limit_exceeded, "Prism commit exceeds the journal frame")
    let store = try journal_store(journal)
    var tx = wal.transaction(store) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    defer tx.close()
    var prefix = try unbaked_key(identity, generation)
    defer prefix.close()
    put_chunked(&tx, &prefix, blob.bytes(), true) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    _ = tx.commit(wait_ms) catch failure:
        error(prism_wal_code(failure.code), failure.message)

func remove_prefix_keys(tx: wal.Transaction*, snap: wal.View*, identity: str, through: u64) -> !:
    let records = (i64)wal_tree.count(snap.root)
    var i: i64 = 0
    while i < records:
        if let item = wal_tree.at(snap.root, (usize)i):
            let key = (str)item.key.span()
            if let gen = parse_unbaked_gen(key, identity):
                if gen <= through:
                    try tx.remove(key)
        i += 1

func remove_snap_chunks(tx: wal.Transaction*, snap: wal.View*, identity: str) -> !:
    var count_key = try snap_count_key(identity)
    defer count_key.close()
    if let listed_copy = try snap_copy(snap, count_key.view()):
        var listed = listed_copy
        defer listed.close()
        try tx.remove(count_key.view())
        let count = parse_u64(listed.view()) else 0
        var index: u64 = 0
        while index < count:
            var key = try snap_chunk_key(identity, (usize)index)
            defer key.close()
            if try snap.get(key.view()) != none:
                try tx.remove(key.view())
            index += 1

pub func reclaim(journal: Journal*, identity: str, owned: tables.Tables*, through: u64, wait_ms: i64) -> !:
    var crate = try encode_tables(journal, identity, owned, through)
    defer crate.close()
    let store = try journal_store(journal)
    var snap = wal.snapshot(store) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    defer snap.close()
    var file_key = try snap_file_key(identity)
    defer file_key.close()
    var old_file: Buffer
    defer old_file.close()
    if let listed = try snap_copy(&snap, file_key.view()):
        old_file = listed
    var kind_key = try snap_kind_key(identity)
    defer kind_key.close()
    var through_key = try snap_through_key(identity)
    defer through_key.close()
    var through_text: Buffer
    defer through_text.close()
    try put_decimal(&through_text, through)
    var inline_prefix: Buffer
    defer inline_prefix.close()
    try inline_prefix.text("s/")
    try inline_prefix.text(identity)
    let inline_cost = encoded_put(inline_prefix.used + 2, crate.used) + encoded_put(inline_prefix.used, 8)
    var tx = wal.transaction(store) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    defer tx.close()
    var new_name: Buffer
    defer new_name.close()
    if inline_cost <= payload_budget:
        tx.put(kind_key.view(), b"inline") catch failure:
            error(prism_wal_code(failure.code), failure.message)
        put_chunked(&tx, &inline_prefix, crate.bytes(), false) catch failure:
            error(prism_wal_code(failure.code), failure.message)
        if old_file.used > 0:
            tx.remove(file_key.view()) catch failure:
                error(prism_wal_code(failure.code), failure.message)
    else:
        var dir = try snap_dir(journal)
        defer dir.close()
        if not try file_io.exists(dir.view()):
            try file_io.create_directory(dir.view())
        try new_name.text(identity)
        try new_name.byte((u8)'.')
        try put_decimal(&new_name, through)
        if not valid_basename(new_name.view()):
            error(invalid, "invalid Prism snapshot basename")
        var path = try join_path(dir.view(), new_name.view())
        defer path.close()
        try file_io.write(path.view(), crate.bytes())
        tx.put(kind_key.view(), b"file") catch failure:
            error(prism_wal_code(failure.code), failure.message)
        tx.put(file_key.view(), new_name.bytes()) catch failure:
            error(prism_wal_code(failure.code), failure.message)
        remove_snap_chunks(&tx, &snap, identity) catch failure:
            error(prism_wal_code(failure.code), failure.message)
        var hashed = try snap_count_key(identity)
        defer hashed.close()
        if try snap.get(hashed.view()) != none:
            tx.remove(hashed.view()) catch failure:
                error(prism_wal_code(failure.code), failure.message)
    tx.put(through_key.view(), through_text.bytes()) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    remove_prefix_keys(&tx, &snap, identity, through) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    _ = tx.commit(wait_ms) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    wal.checkpoint(store, wait_ms) catch failure:
        error(prism_wal_code(failure.code), failure.message)
    if old_file.used > 0 and (new_name.used == 0 or old_file.view() != new_name.view()):
        var dir = try snap_dir(journal)
        defer dir.close()
        var path = try join_path(dir.view(), old_file.view())
        defer path.close()
        file_io.remove(path.view()) catch failure:
            _ = failure

pub func snap_basename(identity: str, through: u64) -> Buffer!:
    var out: Buffer
    errdefer out.close()
    try out.text(identity)
    try out.byte((u8)'.')
    try put_decimal(&out, through)
    return out

## Delete the extents no loaded snapshot or unbaked commit references (see extents).
pub func sweep_extents(journal: Journal*, loaded: const List[LoadedIdentity]*) -> !:
    var keep: List[Buffer]
    defer close_names(&keep)
    for item in loaded.span():
        if let owned = item.tables:
            try extents.note_tables(owned, &keep)
        for layer in item.unbaked.span():
            try extents.note_layer(&layer.layer, &keep)
    try extents.sweep(journal.path.view(), &keep)

## Read the payload of `place` from its extent.
pub func read_extent(journal: Journal*, place: const Locator*) -> Buffer!:
    return try extents.read(journal.path.view(), place)