@zenfs/core 2.7.6 → 2.8.0

package/dist/backends/single_buffer/v2.js

@@ -0,0 +1,1283 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { withErrno } from 'kerium';
+import { alert, crit, debug, err } from 'kerium/log';
+import { array, offsetof, sizeof } from 'memium';
+import { BPlusTree } from 'memium/bplustree';
+import { $from, field, struct, types as t } from 'memium/decorators';
+import { EpochTable, Mutex } from 'memium/locks';
+import { types as primitive } from 'memium/primitives';
+import { Void } from 'memium/types';
+import { _throw } from 'utilium';
+import { BufferView } from 'utilium/buffer';
+import { crc32c } from 'utilium/checksum';
+import { decodeUUID, encodeUUID } from 'utilium/string';
+import { _inode_version, Inode } from '../../internal/inode.js';
+import { SyncMapTransaction } from '../store/map.js';
+import { sb_magic } from './v1.js';
+const hex = (value) => '0x' + value.toString(16).padStart(8, '0');
+const default_epoch_slots = 64;
+const default_block_size = 4096;
+/** Most spare blocks for tree nodes when a file system is created */
+const initial_spares = 16;
+/** Offsets are 32 bits */
+const max_size = 0xffffffff;
+/** Highest ID that fits in an inode */
+const max_id = 0xffffffffn;
+/** A range of bytes */
+let Extent = (() => {
+    var _a, _b;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _offset_decorators;
+    let _offset_initializers = [];
+    let _offset_extraInitializers = [];
+    let _size_decorators;
+    let _size_initializers = [];
+    let _size_extraInitializers = [];
+    var Extent = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _offset_decorators = [(_a = t).uint32.bind(_a)];
+            _size_decorators = [(_b = t).uint32.bind(_b)];
+            __esDecorate(this, null, _offset_decorators, { kind: "accessor", name: "offset", static: false, private: false, access: { has: obj => "offset" in obj, get: obj => obj.offset, set: (obj, value) => { obj.offset = value; } }, metadata: _metadata }, _offset_initializers, _offset_extraInitializers);
+            __esDecorate(this, null, _size_decorators, { kind: "accessor", name: "size", static: false, private: false, access: { has: obj => "size" in obj, get: obj => obj.size, set: (obj, value) => { obj.size = value; } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Extent = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'sbfs.Extent';
+        #offset_accessor_storage = __runInitializers(this, _offset_initializers, void 0);
+        get offset() { return this.#offset_accessor_storage; }
+        set offset(value) { this.#offset_accessor_storage = value; }
+        #size_accessor_storage = (__runInitializers(this, _offset_extraInitializers), __runInitializers(this, _size_initializers, void 0));
+        get size() { return this.#size_accessor_storage; }
+        set size(value) { this.#size_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _size_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Extent = _classThis;
+})();
+export { Extent };
+/** Where the data for an ID is stored */
+let DataExtent = (() => {
+    var _a;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Extent;
+    let _capacity_decorators;
+    let _capacity_initializers = [];
+    let _capacity_extraInitializers = [];
+    var DataExtent = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _capacity_decorators = [(_a = t).uint32.bind(_a)];
+            __esDecorate(this, null, _capacity_decorators, { kind: "accessor", name: "capacity", static: false, private: false, access: { has: obj => "capacity" in obj, get: obj => obj.capacity, set: (obj, value) => { obj.capacity = value; } }, metadata: _metadata }, _capacity_initializers, _capacity_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DataExtent = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'sbfs.DataExtent';
+        #capacity_accessor_storage = __runInitializers(this, _capacity_initializers, void 0);
+        /** Bytes allocated, which can exceed `size` so data can grow in place */
+        get capacity() { return this.#capacity_accessor_storage; }
+        set capacity(value) { this.#capacity_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _capacity_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return DataExtent = _classThis;
+})();
+export { DataExtent };
+/** The roots and allocator state written by a transaction */
+let Commit = (() => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _checksum_decorators;
+    let _checksum_initializers = [];
+    let _checksum_extraInitializers = [];
+    let _generation_decorators;
+    let _generation_initializers = [];
+    let _generation_extraInitializers = [];
+    let _index_root_decorators;
+    let _index_root_initializers = [];
+    let _index_root_extraInitializers = [];
+    let _index_count_decorators;
+    let _index_count_initializers = [];
+    let _index_count_extraInitializers = [];
+    let _free_root_decorators;
+    let _free_root_initializers = [];
+    let _free_root_extraInitializers = [];
+    let _size_root_decorators;
+    let _size_root_initializers = [];
+    let _size_root_extraInitializers = [];
+    let _free_count_decorators;
+    let _free_count_initializers = [];
+    let _free_count_extraInitializers = [];
+    let _free_bytes_decorators;
+    let _free_bytes_initializers = [];
+    let _free_bytes_extraInitializers = [];
+    let _spare_head_decorators;
+    let _spare_head_initializers = [];
+    let _spare_head_extraInitializers = [];
+    let _spare_count_decorators;
+    let _spare_count_initializers = [];
+    let _spare_count_extraInitializers = [];
+    let _spare_total_decorators;
+    let _spare_total_initializers = [];
+    let _spare_total_extraInitializers = [];
+    let _pending_head_decorators;
+    let _pending_head_initializers = [];
+    let _pending_head_extraInitializers = [];
+    let _pending_tail_decorators;
+    let _pending_tail_initializers = [];
+    let _pending_tail_extraInitializers = [];
+    let _pending_bytes_decorators;
+    let _pending_bytes_initializers = [];
+    let _pending_bytes_extraInitializers = [];
+    var Commit = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _checksum_decorators = [(_a = t).uint32.bind(_a)];
+            _generation_decorators = [(_b = t).uint64.bind(_b)];
+            _index_root_decorators = [(_c = t).uint32.bind(_c)];
+            _index_count_decorators = [(_d = t).uint32.bind(_d)];
+            _free_root_decorators = [(_e = t).uint32.bind(_e)];
+            _size_root_decorators = [(_f = t).uint32.bind(_f)];
+            _free_count_decorators = [(_g = t).uint32.bind(_g)];
+            _free_bytes_decorators = [(_h = t).uint32.bind(_h)];
+            _spare_head_decorators = [(_j = t).uint32.bind(_j)];
+            _spare_count_decorators = [(_k = t).uint32.bind(_k)];
+            _spare_total_decorators = [(_l = t).uint32.bind(_l)];
+            _pending_head_decorators = [(_m = t).uint32.bind(_m)];
+            _pending_tail_decorators = [(_o = t).uint32.bind(_o)];
+            _pending_bytes_decorators = [(_p = t).uint32.bind(_p)];
+            __esDecorate(this, null, _checksum_decorators, { kind: "accessor", name: "checksum", static: false, private: false, access: { has: obj => "checksum" in obj, get: obj => obj.checksum, set: (obj, value) => { obj.checksum = value; } }, metadata: _metadata }, _checksum_initializers, _checksum_extraInitializers);
+            __esDecorate(this, null, _generation_decorators, { kind: "accessor", name: "generation", static: false, private: false, access: { has: obj => "generation" in obj, get: obj => obj.generation, set: (obj, value) => { obj.generation = value; } }, metadata: _metadata }, _generation_initializers, _generation_extraInitializers);
+            __esDecorate(this, null, _index_root_decorators, { kind: "accessor", name: "index_root", static: false, private: false, access: { has: obj => "index_root" in obj, get: obj => obj.index_root, set: (obj, value) => { obj.index_root = value; } }, metadata: _metadata }, _index_root_initializers, _index_root_extraInitializers);
+            __esDecorate(this, null, _index_count_decorators, { kind: "accessor", name: "index_count", static: false, private: false, access: { has: obj => "index_count" in obj, get: obj => obj.index_count, set: (obj, value) => { obj.index_count = value; } }, metadata: _metadata }, _index_count_initializers, _index_count_extraInitializers);
+            __esDecorate(this, null, _free_root_decorators, { kind: "accessor", name: "free_root", static: false, private: false, access: { has: obj => "free_root" in obj, get: obj => obj.free_root, set: (obj, value) => { obj.free_root = value; } }, metadata: _metadata }, _free_root_initializers, _free_root_extraInitializers);
+            __esDecorate(this, null, _size_root_decorators, { kind: "accessor", name: "size_root", static: false, private: false, access: { has: obj => "size_root" in obj, get: obj => obj.size_root, set: (obj, value) => { obj.size_root = value; } }, metadata: _metadata }, _size_root_initializers, _size_root_extraInitializers);
+            __esDecorate(this, null, _free_count_decorators, { kind: "accessor", name: "free_count", static: false, private: false, access: { has: obj => "free_count" in obj, get: obj => obj.free_count, set: (obj, value) => { obj.free_count = value; } }, metadata: _metadata }, _free_count_initializers, _free_count_extraInitializers);
+            __esDecorate(this, null, _free_bytes_decorators, { kind: "accessor", name: "free_bytes", static: false, private: false, access: { has: obj => "free_bytes" in obj, get: obj => obj.free_bytes, set: (obj, value) => { obj.free_bytes = value; } }, metadata: _metadata }, _free_bytes_initializers, _free_bytes_extraInitializers);
+            __esDecorate(this, null, _spare_head_decorators, { kind: "accessor", name: "spare_head", static: false, private: false, access: { has: obj => "spare_head" in obj, get: obj => obj.spare_head, set: (obj, value) => { obj.spare_head = value; } }, metadata: _metadata }, _spare_head_initializers, _spare_head_extraInitializers);
+            __esDecorate(this, null, _spare_count_decorators, { kind: "accessor", name: "spare_count", static: false, private: false, access: { has: obj => "spare_count" in obj, get: obj => obj.spare_count, set: (obj, value) => { obj.spare_count = value; } }, metadata: _metadata }, _spare_count_initializers, _spare_count_extraInitializers);
+            __esDecorate(this, null, _spare_total_decorators, { kind: "accessor", name: "spare_total", static: false, private: false, access: { has: obj => "spare_total" in obj, get: obj => obj.spare_total, set: (obj, value) => { obj.spare_total = value; } }, metadata: _metadata }, _spare_total_initializers, _spare_total_extraInitializers);
+            __esDecorate(this, null, _pending_head_decorators, { kind: "accessor", name: "pending_head", static: false, private: false, access: { has: obj => "pending_head" in obj, get: obj => obj.pending_head, set: (obj, value) => { obj.pending_head = value; } }, metadata: _metadata }, _pending_head_initializers, _pending_head_extraInitializers);
+            __esDecorate(this, null, _pending_tail_decorators, { kind: "accessor", name: "pending_tail", static: false, private: false, access: { has: obj => "pending_tail" in obj, get: obj => obj.pending_tail, set: (obj, value) => { obj.pending_tail = value; } }, metadata: _metadata }, _pending_tail_initializers, _pending_tail_extraInitializers);
+            __esDecorate(this, null, _pending_bytes_decorators, { kind: "accessor", name: "pending_bytes", static: false, private: false, access: { has: obj => "pending_bytes" in obj, get: obj => obj.pending_bytes, set: (obj, value) => { obj.pending_bytes = value; } }, metadata: _metadata }, _pending_bytes_initializers, _pending_bytes_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Commit = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'sbfs.Commit';
+        #checksum_accessor_storage = __runInitializers(this, _checksum_initializers, void 0);
+        /** crc32c of the rest of the commit */
+        get checksum() { return this.#checksum_accessor_storage; }
+        set checksum(value) { this.#checksum_accessor_storage = value; }
+        #generation_accessor_storage = (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _generation_initializers, void 0));
+        get generation() { return this.#generation_accessor_storage; }
+        set generation(value) { this.#generation_accessor_storage = value; }
+        #index_root_accessor_storage = (__runInitializers(this, _generation_extraInitializers), __runInitializers(this, _index_root_initializers, void 0));
+        /** ID to extent */
+        get index_root() { return this.#index_root_accessor_storage; }
+        set index_root(value) { this.#index_root_accessor_storage = value; }
+        #index_count_accessor_storage = (__runInitializers(this, _index_root_extraInitializers), __runInitializers(this, _index_count_initializers, void 0));
+        get index_count() { return this.#index_count_accessor_storage; }
+        set index_count(value) { this.#index_count_accessor_storage = value; }
+        #free_root_accessor_storage = (__runInitializers(this, _index_count_extraInitializers), __runInitializers(this, _free_root_initializers, void 0));
+        /** Free extents by offset */
+        get free_root() { return this.#free_root_accessor_storage; }
+        set free_root(value) { this.#free_root_accessor_storage = value; }
+        #size_root_accessor_storage = (__runInitializers(this, _free_root_extraInitializers), __runInitializers(this, _size_root_initializers, void 0));
+        /** Free extents by size then offset */
+        get size_root() { return this.#size_root_accessor_storage; }
+        set size_root(value) { this.#size_root_accessor_storage = value; }
+        #free_count_accessor_storage = (__runInitializers(this, _size_root_extraInitializers), __runInitializers(this, _free_count_initializers, void 0));
+        get free_count() { return this.#free_count_accessor_storage; }
+        set free_count(value) { this.#free_count_accessor_storage = value; }
+        #free_bytes_accessor_storage = (__runInitializers(this, _free_count_extraInitializers), __runInitializers(this, _free_bytes_initializers, void 0));
+        get free_bytes() { return this.#free_bytes_accessor_storage; }
+        set free_bytes(value) { this.#free_bytes_accessor_storage = value; }
+        #spare_head_accessor_storage = (__runInitializers(this, _free_bytes_extraInitializers), __runInitializers(this, _spare_head_initializers, void 0));
+        /** The newest block in the list of spare blocks for tree nodes */
+        get spare_head() { return this.#spare_head_accessor_storage; }
+        set spare_head(value) { this.#spare_head_accessor_storage = value; }
+        #spare_count_accessor_storage = (__runInitializers(this, _spare_head_extraInitializers), __runInitializers(this, _spare_count_initializers, void 0));
+        /** Spare blocks listed by `spare_head` */
+        get spare_count() { return this.#spare_count_accessor_storage; }
+        set spare_count(value) { this.#spare_count_accessor_storage = value; }
+        #spare_total_accessor_storage = (__runInitializers(this, _spare_count_extraInitializers), __runInitializers(this, _spare_total_initializers, void 0));
+        /** Spare blocks in the entire list */
+        get spare_total() { return this.#spare_total_accessor_storage; }
+        set spare_total(value) { this.#spare_total_accessor_storage = value; }
+        #pending_head_accessor_storage = (__runInitializers(this, _spare_total_extraInitializers), __runInitializers(this, _pending_head_initializers, void 0));
+        /** Blocks listing extents that are free once no reader can see them */
+        get pending_head() { return this.#pending_head_accessor_storage; }
+        set pending_head(value) { this.#pending_head_accessor_storage = value; }
+        #pending_tail_accessor_storage = (__runInitializers(this, _pending_head_extraInitializers), __runInitializers(this, _pending_tail_initializers, void 0));
+        get pending_tail() { return this.#pending_tail_accessor_storage; }
+        set pending_tail(value) { this.#pending_tail_accessor_storage = value; }
+        #pending_bytes_accessor_storage = (__runInitializers(this, _pending_tail_extraInitializers), __runInitializers(this, _pending_bytes_initializers, void 0));
+        get pending_bytes() { return this.#pending_bytes_accessor_storage; }
+        set pending_bytes(value) { this.#pending_bytes_accessor_storage = value; }
+        computeChecksum() {
+            return crc32c(new Uint8Array(this.buffer, this.byteOffset + 4, sizeof(Commit) - 4));
+        }
+        update() {
+            this.checksum = this.computeChecksum();
+        }
+        isValid(generation) {
+            return this.generation === generation && this.checksum == this.computeChecksum();
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _pending_bytes_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Commit = _classThis;
+})();
+export { Commit };
+/** State shared by every thread using a file system, which is followed by an epoch table */
+let State = (() => {
+    var _a, _b, _c;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _lock_decorators;
+    let _lock_initializers = [];
+    let _lock_extraInitializers = [];
+    let _generation_decorators;
+    let _generation_initializers = [];
+    let _generation_extraInitializers = [];
+    let _next_id_decorators;
+    let _next_id_initializers = [];
+    let _next_id_extraInitializers = [];
+    let _commits_decorators;
+    let _commits_initializers = [];
+    let _commits_extraInitializers = [];
+    var State = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _lock_decorators = [(_a = t).uint64.bind(_a)];
+            _generation_decorators = [(_b = t).uint64.bind(_b)];
+            _next_id_decorators = [(_c = t).uint64.bind(_c)];
+            _commits_decorators = [field(array(Commit, 2))];
+            __esDecorate(this, null, _lock_decorators, { kind: "accessor", name: "lock", static: false, private: false, access: { has: obj => "lock" in obj, get: obj => obj.lock, set: (obj, value) => { obj.lock = value; } }, metadata: _metadata }, _lock_initializers, _lock_extraInitializers);
+            __esDecorate(this, null, _generation_decorators, { kind: "accessor", name: "generation", static: false, private: false, access: { has: obj => "generation" in obj, get: obj => obj.generation, set: (obj, value) => { obj.generation = value; } }, metadata: _metadata }, _generation_initializers, _generation_extraInitializers);
+            __esDecorate(this, null, _next_id_decorators, { kind: "accessor", name: "next_id", static: false, private: false, access: { has: obj => "next_id" in obj, get: obj => obj.next_id, set: (obj, value) => { obj.next_id = value; } }, metadata: _metadata }, _next_id_initializers, _next_id_extraInitializers);
+            __esDecorate(this, null, _commits_decorators, { kind: "accessor", name: "commits", static: false, private: false, access: { has: obj => "commits" in obj, get: obj => obj.commits, set: (obj, value) => { obj.commits = value; } }, metadata: _metadata }, _commits_initializers, _commits_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            State = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'sbfs.State';
+        #lock_accessor_storage = __runInitializers(this, _lock_initializers, void 0);
+        /** Held by writers */
+        get lock() { return this.#lock_accessor_storage; }
+        set lock(value) { this.#lock_accessor_storage = value; }
+        #generation_accessor_storage = (__runInitializers(this, _lock_extraInitializers), __runInitializers(this, _generation_initializers, void 0));
+        /** The generation of the current commit */
+        get generation() { return this.#generation_accessor_storage; }
+        set generation(value) { this.#generation_accessor_storage = value; }
+        #next_id_accessor_storage = (__runInitializers(this, _generation_extraInitializers), __runInitializers(this, _next_id_initializers, void 0));
+        get next_id() { return this.#next_id_accessor_storage; }
+        set next_id(value) { this.#next_id_accessor_storage = value; }
+        #commits_accessor_storage = (__runInitializers(this, _next_id_extraInitializers), __runInitializers(this, _commits_initializers, void 0));
+        /** The current and previous commits, at their generation modulo 2 */
+        get commits() { return this.#commits_accessor_storage; }
+        set commits(value) { this.#commits_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _commits_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return State = _classThis;
+})();
+export { State };
+/** The start of a block listing extents retired by a generation, which is followed by the extents */
+let PendingHeader = (() => {
+    var _a, _b, _c;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _next_decorators;
+    let _next_initializers = [];
+    let _next_extraInitializers = [];
+    let _count_decorators;
+    let _count_initializers = [];
+    let _count_extraInitializers = [];
+    let _generation_decorators;
+    let _generation_initializers = [];
+    let _generation_extraInitializers = [];
+    var PendingHeader = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _next_decorators = [(_a = t).uint32.bind(_a)];
+            _count_decorators = [(_b = t).uint32.bind(_b)];
+            _generation_decorators = [(_c = t).uint64.bind(_c)];
+            __esDecorate(this, null, _next_decorators, { kind: "accessor", name: "next", static: false, private: false, access: { has: obj => "next" in obj, get: obj => obj.next, set: (obj, value) => { obj.next = value; } }, metadata: _metadata }, _next_initializers, _next_extraInitializers);
+            __esDecorate(this, null, _count_decorators, { kind: "accessor", name: "count", static: false, private: false, access: { has: obj => "count" in obj, get: obj => obj.count, set: (obj, value) => { obj.count = value; } }, metadata: _metadata }, _count_initializers, _count_extraInitializers);
+            __esDecorate(this, null, _generation_decorators, { kind: "accessor", name: "generation", static: false, private: false, access: { has: obj => "generation" in obj, get: obj => obj.generation, set: (obj, value) => { obj.generation = value; } }, metadata: _metadata }, _generation_initializers, _generation_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            PendingHeader = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'sbfs.PendingHeader';
+        #next_accessor_storage = __runInitializers(this, _next_initializers, void 0);
+        get next() { return this.#next_accessor_storage; }
+        set next(value) { this.#next_accessor_storage = value; }
+        #count_accessor_storage = (__runInitializers(this, _next_extraInitializers), __runInitializers(this, _count_initializers, void 0));
+        get count() { return this.#count_accessor_storage; }
+        set count(value) { this.#count_accessor_storage = value; }
+        #generation_accessor_storage = (__runInitializers(this, _count_extraInitializers), __runInitializers(this, _generation_initializers, void 0));
+        get generation() { return this.#generation_accessor_storage; }
+        set generation(value) { this.#generation_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _generation_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return PendingHeader = _classThis;
+})();
+export { PendingHeader };
+/**
+ * The start of a block listing spare blocks, which is followed by their offsets.
+ * The newest block's count is in the commit instead.
+ */
+let SpareHeader = (() => {
+    var _a, _b;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _next_decorators;
+    let _next_initializers = [];
+    let _next_extraInitializers = [];
+    let _count_decorators;
+    let _count_initializers = [];
+    let _count_extraInitializers = [];
+    var SpareHeader = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _next_decorators = [(_a = t).uint32.bind(_a)];
+            _count_decorators = [(_b = t).uint32.bind(_b)];
+            __esDecorate(this, null, _next_decorators, { kind: "accessor", name: "next", static: false, private: false, access: { has: obj => "next" in obj, get: obj => obj.next, set: (obj, value) => { obj.next = value; } }, metadata: _metadata }, _next_initializers, _next_extraInitializers);
+            __esDecorate(this, null, _count_decorators, { kind: "accessor", name: "count", static: false, private: false, access: { has: obj => "count" in obj, get: obj => obj.count, set: (obj, value) => { obj.count = value; } }, metadata: _metadata }, _count_initializers, _count_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SpareHeader = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'sbfs.SpareHeader';
+        #next_accessor_storage = __runInitializers(this, _next_initializers, void 0);
+        get next() { return this.#next_accessor_storage; }
+        set next(value) { this.#next_accessor_storage = value; }
+        #count_accessor_storage = (__runInitializers(this, _next_extraInitializers), __runInitializers(this, _count_initializers, void 0));
+        get count() { return this.#count_accessor_storage; }
+        set count(value) { this.#count_accessor_storage = value; }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _count_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return SpareHeader = _classThis;
+})();
+export { SpareHeader };
+/**
+ * The super block for version 2 of the single-buffer format.
+ * Bytes 0 through 12 have the same layout in every version.
+ */
+let SuperBlock = (() => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    let _classDecorators = [struct.packed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _checksum_decorators;
+    let _checksum_initializers = [];
+    let _checksum_extraInitializers = [];
+    let _magic_decorators;
+    let _magic_initializers = [];
+    let _magic_extraInitializers = [];
+    let _version_decorators;
+    let _version_initializers = [];
+    let _version_extraInitializers = [];
+    let _inode_format_decorators;
+    let _inode_format_initializers = [];
+    let _inode_format_extraInitializers = [];
+    let _required_features_decorators;
+    let _required_features_initializers = [];
+    let _required_features_extraInitializers = [];
+    let _optional_features_decorators;
+    let _optional_features_initializers = [];
+    let _optional_features_extraInitializers = [];
+    let _block_size_decorators;
+    let _block_size_initializers = [];
+    let _block_size_extraInitializers = [];
+    let _total_bytes_decorators;
+    let _total_bytes_initializers = [];
+    let _total_bytes_extraInitializers = [];
+    let _uuid_decorators;
+    let _uuid_initializers = [];
+    let _uuid_extraInitializers = [];
+    let _state_offset_decorators;
+    let _state_offset_initializers = [];
+    let _state_offset_extraInitializers = [];
+    let _epoch_slots_decorators;
+    let _epoch_slots_initializers = [];
+    let _epoch_slots_extraInitializers = [];
+    let _label_decorators;
+    let _label_initializers = [];
+    let _label_extraInitializers = [];
+    let __padding_decorators;
+    let __padding_initializers = [];
+    let __padding_extraInitializers = [];
+    let _lock_decorators;
+    let _lock_initializers = [];
+    let _lock_extraInitializers = [];
+    var SuperBlock = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _checksum_decorators = [(_a = t).uint32.bind(_a)];
+            _magic_decorators = [(_b = t).uint32.bind(_b)];
+            _version_decorators = [(_c = t).uint16.bind(_c)];
+            _inode_format_decorators = [(_d = t).uint16.bind(_d)];
+            _required_features_decorators = [(_e = t).uint32.bind(_e)];
+            _optional_features_decorators = [(_f = t).uint32.bind(_f)];
+            _block_size_decorators = [(_g = t).uint32.bind(_g)];
+            _total_bytes_decorators = [(_h = t).uint64.bind(_h)];
+            _uuid_decorators = [t.uint8(16)];
+            _state_offset_decorators = [(_j = t).uint32.bind(_j)];
+            _epoch_slots_decorators = [(_k = t).uint32.bind(_k)];
+            _label_decorators = [t.char(64)];
+            __padding_decorators = [t.char(128)];
+            _lock_decorators = [(_l = t).uint64.bind(_l)];
+            __esDecorate(this, null, _checksum_decorators, { kind: "accessor", name: "checksum", static: false, private: false, access: { has: obj => "checksum" in obj, get: obj => obj.checksum, set: (obj, value) => { obj.checksum = value; } }, metadata: _metadata }, _checksum_initializers, _checksum_extraInitializers);
+            __esDecorate(this, null, _magic_decorators, { kind: "accessor", name: "magic", static: false, private: false, access: { has: obj => "magic" in obj, get: obj => obj.magic, set: (obj, value) => { obj.magic = value; } }, metadata: _metadata }, _magic_initializers, _magic_extraInitializers);
+            __esDecorate(this, null, _version_decorators, { kind: "accessor", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
+            __esDecorate(this, null, _inode_format_decorators, { kind: "accessor", name: "inode_format", static: false, private: false, access: { has: obj => "inode_format" in obj, get: obj => obj.inode_format, set: (obj, value) => { obj.inode_format = value; } }, metadata: _metadata }, _inode_format_initializers, _inode_format_extraInitializers);
+            __esDecorate(this, null, _required_features_decorators, { kind: "accessor", name: "required_features", static: false, private: false, access: { has: obj => "required_features" in obj, get: obj => obj.required_features, set: (obj, value) => { obj.required_features = value; } }, metadata: _metadata }, _required_features_initializers, _required_features_extraInitializers);
+            __esDecorate(this, null, _optional_features_decorators, { kind: "accessor", name: "optional_features", static: false, private: false, access: { has: obj => "optional_features" in obj, get: obj => obj.optional_features, set: (obj, value) => { obj.optional_features = value; } }, metadata: _metadata }, _optional_features_initializers, _optional_features_extraInitializers);
+            __esDecorate(this, null, _block_size_decorators, { kind: "accessor", name: "block_size", static: false, private: false, access: { has: obj => "block_size" in obj, get: obj => obj.block_size, set: (obj, value) => { obj.block_size = value; } }, metadata: _metadata }, _block_size_initializers, _block_size_extraInitializers);
+            __esDecorate(this, null, _total_bytes_decorators, { kind: "accessor", name: "total_bytes", static: false, private: false, access: { has: obj => "total_bytes" in obj, get: obj => obj.total_bytes, set: (obj, value) => { obj.total_bytes = value; } }, metadata: _metadata }, _total_bytes_initializers, _total_bytes_extraInitializers);
+            __esDecorate(this, null, _uuid_decorators, { kind: "accessor", name: "uuid", static: false, private: false, access: { has: obj => "uuid" in obj, get: obj => obj.uuid, set: (obj, value) => { obj.uuid = value; } }, metadata: _metadata }, _uuid_initializers, _uuid_extraInitializers);
+            __esDecorate(this, null, _state_offset_decorators, { kind: "accessor", name: "state_offset", static: false, private: false, access: { has: obj => "state_offset" in obj, get: obj => obj.state_offset, set: (obj, value) => { obj.state_offset = value; } }, metadata: _metadata }, _state_offset_initializers, _state_offset_extraInitializers);
+            __esDecorate(this, null, _epoch_slots_decorators, { kind: "accessor", name: "epoch_slots", static: false, private: false, access: { has: obj => "epoch_slots" in obj, get: obj => obj.epoch_slots, set: (obj, value) => { obj.epoch_slots = value; } }, metadata: _metadata }, _epoch_slots_initializers, _epoch_slots_extraInitializers);
+            __esDecorate(this, null, _label_decorators, { kind: "accessor", name: "label", static: false, private: false, access: { has: obj => "label" in obj, get: obj => obj.label, set: (obj, value) => { obj.label = value; } }, metadata: _metadata }, _label_initializers, _label_extraInitializers);
+            __esDecorate(this, null, __padding_decorators, { kind: "accessor", name: "_padding", static: false, private: false, access: { has: obj => "_padding" in obj, get: obj => obj._padding, set: (obj, value) => { obj._padding = value; } }, metadata: _metadata }, __padding_initializers, __padding_extraInitializers);
+            __esDecorate(this, null, _lock_decorators, { kind: "accessor", name: "lock", static: false, private: false, access: { has: obj => "lock" in obj, get: obj => obj.lock, set: (obj, value) => { obj.lock = value; } }, metadata: _metadata }, _lock_initializers, _lock_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SuperBlock = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'SuperBlockV2';
+        #checksum_accessor_storage = __runInitializers(this, _checksum_initializers, void 0);
+        /** crc32c of the bytes from 4 up to `lock` */
+        get checksum() { return this.#checksum_accessor_storage; }
+        set checksum(value) { this.#checksum_accessor_storage = value; }
+        #magic_accessor_storage = (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _magic_initializers, void 0));
+        get magic() { return this.#magic_accessor_storage; }
+        set magic(value) { this.#magic_accessor_storage = value; }
+        #version_accessor_storage = (__runInitializers(this, _magic_extraInitializers), __runInitializers(this, _version_initializers, void 0));
+        /**
+         * The version of the on-disk format
+         * 1: v1.10.0+, append-only metadata blocks
+         * 2: copy-on-write B+ trees
+         */
+        get version() { return this.#version_accessor_storage; }
+        set version(value) { this.#version_accessor_storage = value; }
+        #inode_format_accessor_storage = (__runInitializers(this, _version_extraInitializers), __runInitializers(this, _inode_format_initializers, void 0));
+        /** Which format of `Inode` is used */
+        get inode_format() { return this.#inode_format_accessor_storage; }
+        set inode_format(value) { this.#inode_format_accessor_storage = value; }
+        #required_features_accessor_storage = (__runInitializers(this, _inode_format_extraInitializers), __runInitializers(this, _required_features_initializers, void 0));
+        /** Features that must be supported to mount the file system. None are defined. */
+        get required_features() { return this.#required_features_accessor_storage; }
+        set required_features(value) { this.#required_features_accessor_storage = value; }
+        #optional_features_accessor_storage = (__runInitializers(this, _required_features_extraInitializers), __runInitializers(this, _optional_features_initializers, void 0));
+        /** Features that may be ignored. None are defined. */
+        get optional_features() { return this.#optional_features_accessor_storage; }
+        set optional_features(value) { this.#optional_features_accessor_storage = value; }
+        #block_size_accessor_storage = (__runInitializers(this, _optional_features_extraInitializers), __runInitializers(this, _block_size_initializers, void 0));
+        /** Size of tree nodes and other metadata blocks */
+        get block_size() { return this.#block_size_accessor_storage; }
+        set block_size(value) { this.#block_size_accessor_storage = value; }
+        #total_bytes_accessor_storage = (__runInitializers(this, _block_size_extraInitializers), __runInitializers(this, _total_bytes_initializers, void 0));
+        /** The size of the entire file system, including the super block */
+        get total_bytes() { return this.#total_bytes_accessor_storage; }
+        set total_bytes(value) { this.#total_bytes_accessor_storage = value; }
+        #uuid_accessor_storage = (__runInitializers(this, _total_bytes_extraInitializers), __runInitializers(this, _uuid_initializers, void 0));
+        get uuid() { return this.#uuid_accessor_storage; }
+        set uuid(value) { this.#uuid_accessor_storage = value; }
+        #state_offset_accessor_storage = (__runInitializers(this, _uuid_extraInitializers), __runInitializers(this, _state_offset_initializers, void 0));
+        /** Byte offset of the shared state */
+        get state_offset() { return this.#state_offset_accessor_storage; }
+        set state_offset(value) { this.#state_offset_accessor_storage = value; }
+        #epoch_slots_accessor_storage = (__runInitializers(this, _state_offset_extraInitializers), __runInitializers(this, _epoch_slots_initializers, void 0));
+        get epoch_slots() { return this.#epoch_slots_accessor_storage; }
+        set epoch_slots(value) { this.#epoch_slots_accessor_storage = value; }
+        #label_accessor_storage = (__runInitializers(this, _epoch_slots_extraInitializers), __runInitializers(this, _label_initializers, void 0));
+        /** An optional label for the file system */
+        get label() { return this.#label_accessor_storage; }
+        set label(value) { this.#label_accessor_storage = value; }
+        #_padding_accessor_storage = (__runInitializers(this, _label_extraInitializers), __runInitializers(this, __padding_initializers, void 0));
+        get _padding() { return this.#_padding_accessor_storage; }
+        set _padding(value) { this.#_padding_accessor_storage = value; }
+        #lock_accessor_storage = (__runInitializers(this, __padding_extraInitializers), __runInitializers(this, _lock_initializers, void 0));
+        /** Held while the file system is created or upgraded. Not covered by the checksum. */
+        get lock() { return this.#lock_accessor_storage; }
+        set lock(value) { this.#lock_accessor_storage = value; }
+        computeChecksum() {
+            return crc32c(new Uint8Array(this.buffer, this.byteOffset + 4, offsetof(SuperBlock, 'lock') - 4));
+        }
+        update() {
+            this.checksum = this.computeChecksum();
+        }
+        /** Checks that a file system of `byteLength` bytes can be mounted using this super block */
+        validate(byteLength) {
+            const { block_size } = this;
+            if (this.version != 2)
+                throw crit(withErrno('EIO', `sbfs: unsupported version ${this.version}`));
+            if (this.checksum != this.computeChecksum())
+                throw crit(withErrno('EIO', 'sbfs: checksum mismatch for super block'));
+            if (this.required_features)
+                throw crit(withErrno('EIO', `sbfs: unsupported features 0x${this.required_features.toString(16)}`));
+            if (this.inode_format != _inode_version)
+                throw crit(withErrno('EIO', 'sbfs: inode format mismatch'));
+            if (this.total_bytes > BigInt(Math.min(byteLength, max_size)))
+                throw crit(withErrno('EIO', 'sbfs: buffer is smaller than the file system'));
+            if (block_size < 512 || block_size > 0x10000 || block_size & (block_size - 1))
+                throw crit(withErrno('EIO', `sbfs: invalid block size ${block_size}`));
+            if (!this.epoch_slots)
+                throw crit(withErrno('EIO', 'sbfs: no epoch slots'));
+            if ((this.byteOffset + this.state_offset) % 8)
+                throw crit(withErrno('EIO', 'sbfs: misaligned shared state'));
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _lock_extraInitializers);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return SuperBlock = _classThis;
+})();
+export { SuperBlock };
+/** Key for the free tree ordered by size */
+const sizeKey = (size, offset) => (BigInt(size) << 32n) | BigInt(offset);
+/** Thrown when the free trees need more blocks than there are spares */
+const sparesExhausted = withErrno('ENOSPC', 'sbfs: no spare blocks');
+/**
+ * A transaction that changes a file system, which is built from copies of the blocks it changes.
+ * Nothing it does is visible until it is committed.
+ */
+export class WriteTransaction {
+    store;
+    spareScale;
+    buffer;
+    pageSize;
+    generation;
+    /** ID to extent */
+    index;
+    /** Free extents by offset */
+    byOffset;
+    /** Free extents by size then offset */
+    bySize;
+    freeBytes;
+    spareHead;
+    spareCount;
+    spareTotal;
+    /** Spare blocks listed by the base commit in the newest list block, which can not be overwritten */
+    spareFloor;
+    spareCapacity;
+    pendingHead;
+    pendingTail;
+    pendingBytes;
+    /** Blocks allocated by this transaction */
+    fresh = new Set();
+    /** Blocks no commit references, which can be reused immediately */
+    recycled = [];
+    /** Extents that become free once no reader can see them */
+    retired = [];
+    /** Whether the free trees are being changed, during which spares are not refilled */
+    changingFreeTrees = false;
+    /**
+     * @param base The commit this transaction starts from
+     * @param spareScale Multiplies the number of spare blocks to keep
+     */
+    constructor(store, base, spareScale) {
+        this.store = store;
+        this.spareScale = spareScale;
+        this.buffer = store.buffer;
+        this.pageSize = store.blockSize;
+        this.generation = base.generation + 1n;
+        this.freeBytes = base.free_bytes;
+        this.spareHead = base.spare_head;
+        this.spareCount = this.spareFloor = base.spare_count;
+        this.spareTotal = base.spare_total;
+        this.spareCapacity = (this.pageSize - sizeof(SpareHeader)) / 4;
+        this.pendingHead = base.pending_head;
+        this.pendingTail = base.pending_tail;
+        this.pendingBytes = base.pending_bytes;
+        this.index = new BPlusTree(this, { key: primitive.uint64, value: DataExtent }, base.index_root, base.index_count);
+        this.byOffset = new BPlusTree(this, { key: primitive.uint32, value: primitive.uint32 }, base.free_root, base.free_count);
+        this.bySize = new BPlusTree(this, { key: primitive.uint64, value: Void }, base.size_root, base.free_count);
+        this.releasePending(store.epochs.oldest());
+    }
+    offsetOf(block) {
+        return this.store.byteOffset + block;
+    }
+    alloc() {
+        let block = this.recycled.pop();
+        if (block === undefined) {
+            this.refillSpares();
+            block = this.popSpare();
+        }
+        if (block === undefined) {
+            if (this.changingFreeTrees)
+                throw sparesExhausted;
+            throw err(withErrno('ENOSPC', 'sbfs: no space for metadata'));
+        }
+        this.fresh.add(block);
+        return block;
+    }
+    free(block) {
+        if (this.fresh.delete(block))
+            this.recycled.push(block);
+        else
+            this.retired.push([block, this.pageSize]);
+    }
+    // Spare blocks
+    /** Minimum blocks available for tree nodes, enough to copy and split a path in both free trees */
+    lowWater() {
+        return 4 * (Math.max(this.byOffset.height, this.bySize.height) + 1) * this.spareScale;
+    }
+    /** Blocks that can be allocated without changing the free trees */
+    availableBlocks() {
+        return this.spareTotal + this.recycled.length;
+    }
+    /** Takes a spare block, if there are any */
+    popSpare() {
+        while (this.spareHead && !this.spareCount) {
+            const next = this.store.getUint32(this.spareHead + offsetof(SpareHeader, 'next'), true);
+            this.free(this.spareHead);
+            this.spareHead = next;
+            this.spareCount = this.spareFloor = next && this.store.getUint32(next + offsetof(SpareHeader, 'count'), true);
+        }
+        if (!this.spareCount)
+            return;
+        this.spareCount--;
+        this.spareTotal--;
+        return this.store.getUint32(this.spareHead + sizeof(SpareHeader) + this.spareCount * 4, true);
+    }
+    /** Adds a free block to the spare blocks */
+    pushSpare(block) {
+        if (this.spareHead && this.spareCount >= this.spareFloor && this.spareCount < this.spareCapacity) {
+            this.store.setUint32(this.spareHead + sizeof(SpareHeader) + this.spareCount * 4, block, true);
+            this.spareCount++;
+            this.spareTotal++;
+            return;
+        }
+        // The block becomes the newest list block
+        if (this.spareHead)
+            this.store.setUint32(this.spareHead + offsetof(SpareHeader, 'count'), this.spareCount, true);
+        this.store.setUint32(block + offsetof(SpareHeader, 'next'), this.spareHead, true);
+        this.spareHead = block;
+        this.spareCount = this.spareFloor = 0;
+        this.fresh.add(block);
+    }
+    /** Refills the spare blocks if they are below the low-water mark */
+    refillSpares() {
+        if (this.changingFreeTrees)
+            return;
+        const low = this.lowWater();
+        if (this.availableBlocks() >= low)
+            return;
+        this.changeFreeTrees(() => {
+            const total = Math.floor(this.store.byteLength / this.pageSize);
+            for (let blocks = Math.min(low * 2, total); blocks >= 1 && this.availableBlocks() < low;) {
+                try {
+                    const offset = this.takeBestFit(blocks * this.pageSize);
+                    for (let i = 0; i < blocks; i++)
+                        this.pushSpare(offset + i * this.pageSize);
+                }
+                catch (e) {
+                    if (e === sparesExhausted || e.code != 'ENOSPC')
+                        throw e;
+                    blocks >>= 1;
+                }
+            }
+        });
+    }
+    // Free space
+    changeFreeTrees(change) {
+        this.changingFreeTrees = true;
+        try {
+            return change();
+        }
+        finally {
+            this.changingFreeTrees = false;
+        }
+    }
+    /** Removes the free extent at `offset`, then returns everything after its first `size` bytes to free space */
+    split(offset, length, size) {
+        this.bySize.delete(sizeKey(length, offset));
+        this.byOffset.delete(offset);
+        if (length > size) {
+            this.byOffset.set(offset + size, length - size);
+            this.bySize.set(sizeKey(length - size, offset + size), undefined);
+        }
+        this.freeBytes -= size;
+    }
+    /** Takes the smallest free extent that fits `size` bytes */
+    takeBestFit(size) {
+        const found = this.bySize.ceiling(sizeKey(size, 0));
+        if (!found)
+            throw withErrno('ENOSPC', 'sbfs: no free extent is large enough');
+        const offset = Number(found[0] & 0xffffffffn);
+        this.split(offset, Number(found[0] >> 32n), size);
+        return offset;
+    }
+    /** Allocates `size` bytes for data, leaving enough blocks to change the free trees */
+    allocate(size) {
+        this.refillSpares();
+        if (this.availableBlocks() < this.lowWater())
+            throw withErrno('ENOSPC', 'sbfs: no space left');
+        return this.changeFreeTrees(() => this.takeBestFit(size));
+    }
+    /** Frees an extent no reader can see, merging it with adjacent free extents */
+    freeExtent(offset, size) {
+        if (!size)
+            return;
+        this.refillSpares();
+        this.changeFreeTrees(() => {
+            let start = offset, length = size;
+            const prev = this.byOffset.floor(offset);
+            if (prev && prev[0] + prev[1] > offset)
+                throw crit(withErrno('EIO', `sbfs: extent at ${hex(offset)} was freed twice`));
+            if (prev && prev[0] + prev[1] == offset) {
+                start = prev[0];
+                length += prev[1];
+                this.bySize.delete(sizeKey(prev[1], prev[0]));
+            }
+            const next = this.byOffset.ceiling(offset);
+            if (next && next[0] < offset + size)
+                throw crit(withErrno('EIO', `sbfs: extent at ${hex(offset)} was freed twice`));
+            if (next && next[0] == offset + size) {
+                length += next[1];
+                this.byOffset.delete(next[0]);
+                this.bySize.delete(sizeKey(next[1], next[0]));
+            }
+            this.byOffset.set(start, length);
+            this.bySize.set(sizeKey(length, start), undefined);
+            this.freeBytes += size;
+        });
+    }
+    /** Frees an extent once no reader can see this transaction's base */
+    retire(offset, size) {
+        if (size)
+            this.retired.push([offset, size]);
+    }
+    // Pending extents
+    /** Frees extents retired by generations that readers no longer see */
+    releasePending(oldest) {
+        const { store } = this;
+        while (this.pendingHead) {
+            const block = this.pendingHead;
+            if (oldest !== undefined && store.getBigUint64(block + offsetof(PendingHeader, 'generation'), true) > oldest)
+                break;
+            // Released blocks become spares, up to twice the low-water mark
+            for (let i = 0; i < store.getUint32(block + offsetof(PendingHeader, 'count'), true); i++) {
+                const entry = block + sizeof(PendingHeader) + i * sizeof(Extent);
+                const offset = store.getUint32(entry + offsetof(Extent, 'offset'), true);
+                const size = store.getUint32(entry + offsetof(Extent, 'size'), true);
+                this.pendingBytes -= size;
+                if (size == this.pageSize && this.availableBlocks() < 2 * this.lowWater())
+                    this.pushSpare(offset);
+                else
+                    this.freeExtent(offset, size);
+            }
+            const last = block == this.pendingTail;
+            this.pendingHead = last ? 0 : store.getUint32(block + offsetof(PendingHeader, 'next'), true);
+            if (last)
+                this.pendingTail = 0;
+            // The base commit still lists this block
+            this.retire(block, this.pageSize);
+        }
+    }
+    appendPending(offset, size) {
+        const { store } = this;
+        let tail = this.pendingTail;
+        if (!tail
+            || store.getBigUint64(tail + offsetof(PendingHeader, 'generation'), true) !== this.generation
+            || store.getUint32(tail + offsetof(PendingHeader, 'count'), true) >= Math.floor((this.pageSize - sizeof(PendingHeader)) / sizeof(Extent))) {
+            const block = this.alloc();
+            store.setUint32(block + offsetof(PendingHeader, 'next'), 0, true);
+            store.setUint32(block + offsetof(PendingHeader, 'count'), 0, true);
+            store.setBigUint64(block + offsetof(PendingHeader, 'generation'), this.generation, true);
+            // Earlier commits stop at their own tail
+            if (tail)
+                store.setUint32(tail + offsetof(PendingHeader, 'next'), block, true);
+            else
+                this.pendingHead = block;
+            this.pendingTail = tail = block;
+        }
+        const count = store.getUint32(tail + offsetof(PendingHeader, 'count'), true);
+        const entry = tail + sizeof(PendingHeader) + count * sizeof(Extent);
+        store.setUint32(entry + offsetof(Extent, 'offset'), offset, true);
+        store.setUint32(entry + offsetof(Extent, 'size'), size, true);
+        store.setUint32(tail + offsetof(PendingHeader, 'count'), count + 1, true);
+        this.pendingBytes += size;
+    }
+    /** Records retired extents in the pending list, then writes this transaction's roots and allocator state to `commit` */
+    commit(commit) {
+        while (this.retired.length) {
+            const batch = this.retired;
+            this.retired = [];
+            for (const [offset, size] of batch)
+                this.appendPending(offset, size);
+        }
+        for (const block of this.recycled)
+            this.pushSpare(block);
+        this.recycled = [];
+        Object.assign(commit, {
+            generation: this.generation,
+            index_root: this.index.root,
+            index_count: this.index.size,
+            free_root: this.byOffset.root,
+            size_root: this.bySize.root,
+            free_count: this.byOffset.size,
+            free_bytes: this.freeBytes,
+            spare_head: this.spareHead,
+            spare_count: this.spareCount,
+            spare_total: this.spareTotal,
+            pending_head: this.pendingHead,
+            pending_tail: this.pendingTail,
+            pending_bytes: this.pendingBytes,
+        });
+        commit.update();
+    }
+}
+const defaultStateSize = sizeof(State) + EpochTable.sizeOf(default_epoch_slots);
+/**
+ * A store for version 2 of the single-buffer format.
+ *
+ * Every change is a transaction that copies what it modifies.
+ * Readers never block, and an interrupted writer does not change the file system.
+ * @category Stores and Transactions
+ */
+export class SingleBufferStore extends DataView {
+    flags = ['partial'];
+    name = 'sbfs';
+    type = 0x73626673; // 'sbfs'
+    get uuid() {
+        return decodeUUID(this.superblock.uuid);
+    }
+    superblock;
+    /**
+     * The entire file system
+     * @internal
+     */
+    bytes;
+    /** @internal */
+    blockSize;
+    /** @internal */
+    epochs;
+    mutex;
+    generation;
+    nextId;
+    commits;
+    /** The index of the version being read */
+    index;
+    /**
+     * Opens a file system, or creates one if `format` is set.
+     * When creating one, byte ranges in `used` are kept, and the first transaction runs `populate` after making everything else free.
+     */
+    constructor(buffer, byteOffset = 0, byteLength, options = {}) {
+        if (ArrayBuffer.isView(buffer))
+            super(buffer.buffer, buffer.byteOffset + byteOffset, byteLength ?? buffer.byteLength - byteOffset);
+        else
+            super(buffer, byteOffset, byteLength);
+        if (this.byteOffset % 8)
+            throw crit(withErrno('EINVAL', 'sbfs: buffer must be 8-byte aligned'));
+        if (this.byteLength < sizeof(SuperBlock))
+            throw crit(withErrno('EINVAL', 'sbfs: buffer is too small for a file system'));
+        this.bytes = new Uint8Array(this.buffer, this.byteOffset, this.byteLength);
+        this.superblock = new SuperBlock(this.buffer, this.byteOffset);
+        const format = options.format === true ? {} : options.format;
+        let { superblock } = this;
+        const gaps = [];
+        let spares = 0, spareBlocks = 0;
+        if (!format)
+            this.superblock.validate(this.byteLength);
+        else {
+            if (this.byteLength > max_size)
+                throw crit(withErrno('EINVAL', 'sbfs: buffers larger than 4 GiB are not supported'));
+            const used = [[0, sizeof(SuperBlock)], ...(format.used ?? [])];
+            used.sort(([a], [b]) => a - b);
+            let cursor = 0;
+            for (const [start, end] of used) {
+                if (start > cursor)
+                    gaps.push([cursor, start]);
+                cursor = Math.max(cursor, end);
+            }
+            if (cursor < this.byteLength)
+                gaps.push([cursor, this.byteLength]);
+            const take = (size, alignment) => {
+                const align = (start) => Math.ceil((this.byteOffset + start) / alignment) * alignment - this.byteOffset;
+                const index = gaps.findIndex(([start, end]) => align(start) + size <= end);
+                if (index == -1)
+                    throw crit(withErrno('ENOSPC', 'sbfs: buffer is too small for a file system'));
+                const [start, end] = gaps[index];
+                const aligned = align(start);
+                const rest = [
+                    [start, aligned],
+                    [aligned + size, end],
+                ];
+                gaps.splice(index, 1, ...rest.filter(([s, e]) => e > s));
+                return aligned;
+            };
+            superblock = new SuperBlock();
+            Object.assign(superblock, {
+                magic: sb_magic,
+                version: 2,
+                inode_format: _inode_version,
+                block_size: default_block_size,
+                epoch_slots: default_epoch_slots,
+                total_bytes: BigInt(this.byteLength),
+                uuid: format.uuid ?? encodeUUID(crypto.randomUUID()),
+                state_offset: take(defaultStateSize, 8),
+            });
+            if (format.label)
+                superblock.label = format.label;
+            const free = gaps.reduce((total, [start, end]) => total + end - start, 0);
+            spareBlocks = Math.min(initial_spares, Math.floor(free / superblock.block_size / 4));
+            if (spareBlocks < 4)
+                throw crit(withErrno('EINVAL', 'sbfs: buffer is too small for a file system'));
+            spares = take(spareBlocks * superblock.block_size, 1);
+        }
+        const { block_size, state_offset, epoch_slots } = superblock;
+        const state = this.byteOffset + state_offset;
+        const commits = state + offsetof(State, 'commits');
+        this.blockSize = block_size;
+        this.mutex = new Mutex(this.buffer, state + offsetof(State, 'lock'));
+        this.generation = new BigInt64Array(this.buffer, state + offsetof(State, 'generation'), 1);
+        this.nextId = new BigInt64Array(this.buffer, state + offsetof(State, 'next_id'), 1);
+        this.commits = [new Commit(this.buffer, commits), new Commit(this.buffer, commits + sizeof(Commit))];
+        this.epochs = new EpochTable(this.buffer, state + sizeof(State), epoch_slots);
+        const readOnly = {
+            buffer: this.buffer,
+            pageSize: this.blockSize,
+            offsetOf: block => this.byteOffset + block,
+            alloc: () => _throw(withErrno('EROFS', 'sbfs: snapshots are read-only')),
+            free: () => _throw(withErrno('EROFS', 'sbfs: snapshots are read-only')),
+        };
+        this.index = new BPlusTree(readOnly, { key: primitive.uint64, value: DataExtent });
+        if (!format) {
+            if (!this.withCurrentCommit((commit, generation) => commit.isValid(generation)))
+                throw crit(withErrno('EIO', 'sbfs: the current commit is corrupt'));
+            return;
+        }
+        this.bytes.fill(0, state_offset, state_offset + defaultStateSize);
+        Atomics.store(this.nextId, 0, format.nextId ?? 2n);
+        this.setUint32(spares + offsetof(SpareHeader, 'next'), 0, true);
+        for (let i = 1; i < spareBlocks; i++)
+            this.setUint32(spares + sizeof(SpareHeader) + (i - 1) * 4, spares + i * block_size, true);
+        Object.assign(this.commits[0], { spare_head: spares, spare_count: spareBlocks - 1, spare_total: spareBlocks - 1 });
+        this.commits[0].update();
+        this.write(tx => {
+            for (const [start, end] of gaps)
+                tx.freeExtent(start, end - start);
+            format.populate?.(tx);
+        });
+        superblock.lock = Atomics.load(new BigInt64Array(this.buffer, this.byteOffset + offsetof(SuperBlock, 'lock'), 1), 0);
+        superblock.update();
+        this.bytes.set(new Uint8Array(superblock.buffer, superblock.byteOffset, sizeof(SuperBlock)), 0);
+    }
+    /** Reads the current commit, retrying if a writer replaces it while reading */
+    withCurrentCommit(read) {
+        for (;;) {
+            const generation = Atomics.load(this.generation, 0);
+            const result = read(this.commits[Number(generation & 1n)], generation);
+            if (Atomics.load(this.generation, 0) === generation)
+                return result;
+        }
+    }
+    /** Runs `read` against the current version, which stays valid until `read` returns */
+    read(read) {
+        for (;;) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const generation = Atomics.load(this.generation, 0);
+                const _ = __addDisposableResource(env_1, this.epochs.pin(generation), false);
+                const { index_root, index_count } = this.commits[Number(generation & 1n)];
+                if (Atomics.load(this.generation, 0) !== generation)
+                    continue;
+                this.index.reset(index_root, index_count);
+                return read(this.index);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+    }
+    /** Runs `change` in a write transaction, retrying with more spare blocks if the free trees run out of them */
+    write(change) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const lock = __addDisposableResource(env_2, this.mutex.lock(), false);
+            for (let attempt = 0;; attempt++) {
+                try {
+                    const generation = Atomics.load(this.generation, 0);
+                    const base = this.commits[Number(generation & 1n)];
+                    if (!base.isValid(generation))
+                        throw crit(withErrno('EIO', `sbfs: commit for generation ${generation} is corrupt`));
+                    const tx = new WriteTransaction(this, base, 2 ** attempt);
+                    const result = change(tx);
+                    tx.commit(this.commits[Number(tx.generation & 1n)]);
+                    if (!lock.renew())
+                        throw crit(withErrno('EBUSY', 'sbfs: lost the write lock before committing'));
+                    Atomics.store(this.generation, 0, tx.generation);
+                    return result;
+                }
+                catch (e) {
+                    if (e !== sparesExhausted || attempt >= 3)
+                        throw e;
+                    debug('sbfs: retrying transaction with more spare blocks');
+                }
+            }
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    // Store
+    keys() {
+        return this.read(index => Array.from(index.keys(), Number));
+    }
+    get(id, offset = 0, end) {
+        return this.read(index => {
+            const extent = index.get(BigInt(id));
+            if (!extent)
+                return;
+            const start = this.byteOffset + extent.offset;
+            return new Uint8Array(this.buffer.slice(start + Math.min(offset, extent.size), start + Math.min(end ?? extent.size, extent.size)));
+        });
+    }
+    set(id, data, offset) {
+        if (id === 0 && offset === undefined && data.length < sizeof(Inode))
+            throw alert(withErrno('EIO', `sbfs: tried to set ${data.length} bytes for id 0!`));
+        const key = BigInt(id);
+        this.write(tx => {
+            const old = tx.index.get(key);
+            const kept = offset === undefined ? 0 : (old?.size ?? 0);
+            const start = offset ?? 0;
+            const extent = Object.assign(new DataExtent(), { size: Math.max(kept, start + data.length) });
+            // Bytes past the old size are not visible to readers of older versions
+            if (old && offset !== undefined && start >= old.size && extent.size <= old.capacity) {
+                extent.offset = old.offset;
+                extent.capacity = old.capacity;
+            }
+            else {
+                // Partial writes keep the old capacity, and data that outgrows it gets room to keep growing
+                const capacity = offset === undefined ? 0 : (old?.capacity ?? 0);
+                if (extent.size <= capacity)
+                    extent.capacity = capacity;
+                else if (capacity)
+                    extent.capacity = Math.max(extent.size, Math.floor(capacity * 1.5));
+                else
+                    extent.capacity = extent.size;
+                try {
+                    extent.offset = extent.capacity ? tx.allocate(extent.capacity) : 0;
+                }
+                catch (e) {
+                    if (e === sparesExhausted || e.code != 'ENOSPC' || extent.capacity == extent.size)
+                        throw e;
+                    extent.capacity = extent.size;
+                    extent.offset = tx.allocate(extent.size);
+                }
+                if (old) {
+                    this.bytes.copyWithin(extent.offset, old.offset, old.offset + kept);
+                    tx.retire(old.offset, old.capacity);
+                }
+            }
+            this.bytes.fill(0, extent.offset + kept, extent.offset + start);
+            this.bytes.set(data, extent.offset + start);
+            tx.index.set(key, extent);
+        });
+    }
+    delete(id) {
+        const key = BigInt(id);
+        this.write(tx => {
+            const old = tx.index.get(key);
+            if (!old)
+                return;
+            tx.index.delete(key);
+            tx.retire(old.offset, old.capacity);
+        });
+    }
+    allocId() {
+        const id = Atomics.add(this.nextId, 0, 2n);
+        if (id + 1n > max_id)
+            throw err(withErrno('ENOSPC', 'sbfs: no IDs available'));
+        return [Number(id), Number(id + 1n)];
+    }
+    usage() {
+        return {
+            totalSpace: Number(this.superblock.total_bytes),
+            freeSpace: this.withCurrentCommit(commit => commit.free_bytes + commit.spare_total * this.blockSize + commit.pending_bytes),
+        };
+    }
+    _fs;
+    get fs() {
+        return this._fs;
+    }
+    set fs(fs) {
+        if (this.buffer.constructor.name === 'SharedArrayBuffer')
+            fs?.attributes.set('no_id_tables', true);
+        this._fs = fs;
+    }
+    sync() {
+        return Promise.resolve();
+    }
+    transaction() {
+        return new SyncMapTransaction(this);
+    }
+}