@zenfs/core 2.0.0 → 2.1.0

package/dist/backends/single_buffer.js

@@ -32,24 +32,97 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     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;
+});
 var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
-import { _throw, deserialize, member, offsetof, serialize, sizeof, struct, types as t } from 'utilium';
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+import { withErrno } from 'kerium';
+import { alert, crit, err, warn } from 'kerium/log';
+import { field, offsetof, packed, sizeof, struct, types as t } from 'memium';
+import { BufferView } from 'utilium/buffer.js';
 import { crc32c } from 'utilium/checksum.js';
-import { Errno, ErrnoError } from '../internal/error.js';
-import { _inode_version } from '../internal/inode.js';
-import { crit, warn } from '../internal/log.js';
+import { decodeUUID, encodeUUID } from 'utilium/string.js';
+import { _inode_version, Inode } from '../internal/inode.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction } from './store/map.js';
-import { stringifyUUID } from '../utils.js';
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { format } = new Intl.NumberFormat('en-US', {
+    notation: 'compact',
+    maximumFractionDigits: 2,
+    unit: 'byte',
+    unitDisplay: 'narrow',
+});
 let MetadataEntry = (() => {
+    var _MetadataEntry_id_accessor_storage, _MetadataEntry_offset__accessor_storage, _MetadataEntry_offset_accessor_storage, _MetadataEntry_size_accessor_storage;
     var _a, _b, _c, _d;
-    let _classDecorators = [struct()];
+    let _classDecorators = [struct(packed)];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
+    let _classSuper = BufferView;
     let _id_decorators;
     let _id_initializers = [];
     let _id_extraInitializers = [];
@@ -62,30 +135,47 @@ let MetadataEntry = (() => {
     let _size_decorators;
     let _size_initializers = [];
     let _size_extraInitializers = [];
-    var MetadataEntry = _classThis = class {
+    var MetadataEntry = _classThis = class extends _classSuper {
+        /** Inode or data ID */
+        get id() { return __classPrivateFieldGet(this, _MetadataEntry_id_accessor_storage, "f"); }
+        set id(value) { __classPrivateFieldSet(this, _MetadataEntry_id_accessor_storage, value, "f"); }
+        /** Reserved for 64-bit offset expansion */
+        get offset_() { return __classPrivateFieldGet(this, _MetadataEntry_offset__accessor_storage, "f"); }
+        set offset_(value) { __classPrivateFieldSet(this, _MetadataEntry_offset__accessor_storage, value, "f"); }
+        /** Offset into the buffer the data is stored at. */
+        get offset() { return __classPrivateFieldGet(this, _MetadataEntry_offset_accessor_storage, "f"); }
+        set offset(value) { __classPrivateFieldSet(this, _MetadataEntry_offset_accessor_storage, value, "f"); }
+        /** The size of the data */
+        get size() { return __classPrivateFieldGet(this, _MetadataEntry_size_accessor_storage, "f"); }
+        set size(value) { __classPrivateFieldSet(this, _MetadataEntry_size_accessor_storage, value, "f"); }
+        toString() {
+            return `<MetadataEntry @ 0x${this.byteOffset.toString(16).padStart(8, '0')}>`;
+        }
         constructor() {
-            /** Inode or data ID */
-            this.id = __runInitializers(this, _id_initializers, 0);
-            /** Reserved for 64-bit offset expansion */
-            this.offset_ = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _offset__initializers, 0));
-            /** Offset into the buffer the data is stored at. */
-            this.offset = (__runInitializers(this, _offset__extraInitializers), __runInitializers(this, _offset_initializers, 0));
-            /** The size of the data */
-            this.size = (__runInitializers(this, _offset_extraInitializers), __runInitializers(this, _size_initializers, 0));
+            super(...arguments);
+            _MetadataEntry_id_accessor_storage.set(this, __runInitializers(this, _id_initializers, void 0));
+            _MetadataEntry_offset__accessor_storage.set(this, (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _offset__initializers, void 0)));
+            _MetadataEntry_offset_accessor_storage.set(this, (__runInitializers(this, _offset__extraInitializers), __runInitializers(this, _offset_initializers, void 0)));
+            _MetadataEntry_size_accessor_storage.set(this, (__runInitializers(this, _offset_extraInitializers), __runInitializers(this, _size_initializers, void 0)));
             __runInitializers(this, _size_extraInitializers);
         }
     };
+    _MetadataEntry_id_accessor_storage = new WeakMap();
+    _MetadataEntry_offset__accessor_storage = new WeakMap();
+    _MetadataEntry_offset_accessor_storage = new WeakMap();
+    _MetadataEntry_size_accessor_storage = new WeakMap();
     __setFunctionName(_classThis, "MetadataEntry");
     (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
         _id_decorators = [(_a = t).uint32.bind(_a)];
         _offset__decorators = [(_b = t).uint32.bind(_b)];
         _offset_decorators = [(_c = t).uint32.bind(_c)];
         _size_decorators = [(_d = t).uint32.bind(_d)];
-        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
-        __esDecorate(null, null, _offset__decorators, { kind: "field", 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(null, null, _offset_decorators, { kind: "field", 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(null, null, _size_decorators, { kind: "field", 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(_classThis, null, _id_decorators, { kind: "accessor", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(_classThis, 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(_classThis, 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(_classThis, 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);
         MetadataEntry = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -97,80 +187,148 @@ let MetadataEntry = (() => {
  * Number of entries per block of metadata
  */
 const entries_per_block = 255;
+/**
+ * Number of times to attempt to acquire a lock before giving up.
+ */
+const max_lock_attempts = 5;
 /**
  * A block of metadata for a single-buffer file system.
  * This metadata maps IDs (for inodes and data) to actual offsets in the buffer.
  * This is done since IDs are not guaranteed to be sequential.
  */
 let MetadataBlock = (() => {
+    var _MetadataBlock_checksum_accessor_storage, _MetadataBlock_timestamp_accessor_storage, _MetadataBlock_previous_offset_accessor_storage, _MetadataBlock_items_accessor_storage, _MetadataBlock_locked_accessor_storage;
     var _a, _b, _c, _d;
-    let _classDecorators = [struct()];
+    let _classDecorators = [struct(packed)];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
+    let _classSuper = Int32Array;
     let _checksum_decorators;
     let _checksum_initializers = [];
     let _checksum_extraInitializers = [];
     let _timestamp_decorators;
     let _timestamp_initializers = [];
     let _timestamp_extraInitializers = [];
-    let _previous_offset__decorators;
-    let _previous_offset__initializers = [];
-    let _previous_offset__extraInitializers = [];
     let _previous_offset_decorators;
     let _previous_offset_initializers = [];
     let _previous_offset_extraInitializers = [];
-    let _entries_decorators;
-    let _entries_initializers = [];
-    let _entries_extraInitializers = [];
-    var MetadataBlock = _classThis = class {
-        constructor(superblock = _throw(new ErrnoError(Errno.EINVAL, 'Metadata block must be initialized with a superblock')), offset = 0) {
-            this.superblock = superblock;
-            this.offset = offset;
-            /**
-             * The crc32c checksum for the metadata block.
-             * @privateRemarks Keep this first!
-             */
-            this.checksum = __runInitializers(this, _checksum_initializers, 0);
-            /** The (last) time this metadata block was updated */
-            this.timestamp = (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _timestamp_initializers, Date.now()));
-            /** Reserved for 64-bit offset expansion */
-            this.previous_offset_ = (__runInitializers(this, _timestamp_extraInitializers), __runInitializers(this, _previous_offset__initializers, 0));
-            /** Offset to the previous metadata block */
-            this.previous_offset = (__runInitializers(this, _previous_offset__extraInitializers), __runInitializers(this, _previous_offset_initializers, 0));
-            this._previous = __runInitializers(this, _previous_offset_extraInitializers);
-            /** Metadata entries. */
-            this.entries = __runInitializers(this, _entries_initializers, Array.from({ length: entries_per_block }, () => new MetadataEntry()));
-            __runInitializers(this, _entries_extraInitializers);
-            this.superblock = superblock;
-            this.offset = offset;
-            if (!offset)
-                return; // fresh block
-            deserialize(this, superblock.store._buffer.subarray(offset, offset + sizeof(MetadataBlock)));
-            if (!checksumMatches(this))
-                throw crit(new ErrnoError(Errno.EIO, 'SingleBuffer: Checksum mismatch for metadata block at 0x' + offset.toString(16)));
-        }
+    let _items_decorators;
+    let _items_initializers = [];
+    let _items_extraInitializers = [];
+    let _locked_decorators;
+    let _locked_initializers = [];
+    let _locked_extraInitializers = [];
+    var MetadataBlock = _classThis = class extends _classSuper {
+        /**
+         * The crc32c checksum for the metadata block.
+         * @privateRemarks Keep this first!
+         */
+        get checksum() { return __classPrivateFieldGet(this, _MetadataBlock_checksum_accessor_storage, "f"); }
+        set checksum(value) { __classPrivateFieldSet(this, _MetadataBlock_checksum_accessor_storage, value, "f"); }
+        /** The (last) time this metadata block was updated */
+        get timestamp() { return __classPrivateFieldGet(this, _MetadataBlock_timestamp_accessor_storage, "f"); }
+        set timestamp(value) { __classPrivateFieldSet(this, _MetadataBlock_timestamp_accessor_storage, value, "f"); }
+        /** Offset to the previous metadata block */
+        get previous_offset() { return __classPrivateFieldGet(this, _MetadataBlock_previous_offset_accessor_storage, "f"); }
+        set previous_offset(value) { __classPrivateFieldSet(this, _MetadataBlock_previous_offset_accessor_storage, value, "f"); }
         get previous() {
             var _a;
             if (!this.previous_offset)
                 return;
-            (_a = this._previous) !== null && _a !== void 0 ? _a : (this._previous = new MetadataBlock(this.superblock, this.previous_offset));
+            (_a = this._previous) !== null && _a !== void 0 ? _a : (this._previous = new MetadataBlock(this.buffer, this.previous_offset));
             return this._previous;
         }
+        get offsetHex() {
+            return '0x' + this.byteOffset.toString(16).padStart(8, '0');
+        }
+        /** Metadata entries. */
+        get items() { return __classPrivateFieldGet(this, _MetadataBlock_items_accessor_storage, "f"); }
+        set items(value) { __classPrivateFieldSet(this, _MetadataBlock_items_accessor_storage, value, "f"); }
+        toString(long = false) {
+            if (!long)
+                return `<MetadataBlock @ ${this.offsetHex}>`;
+            let text = [
+                `---- Metadata block at ${this.offsetHex} ----`,
+                `Checksum: 0x${this.checksum.toString(16).padStart(8, '0')}`,
+                `Last updated: ${new Date(Number(this.timestamp)).toLocaleString()}`,
+                `Previous block: 0x${this.previous_offset.toString(16).padStart(8, '0')}`,
+                'Entries:',
+            ].join('\n');
+            for (const entry of this.items) {
+                if (!entry.offset)
+                    continue;
+                text += `\n\t0x${entry.id.toString(16).padStart(8, '0')}: ${format(entry.size).padStart(5)} at 0x${entry.offset.toString(16).padStart(8, '0')}`;
+            }
+            return text;
+        }
+        /**
+         * If non-zero, this block is locked for writing.
+         * Note a int32 is used for `Atomics.wait`
+         */
+        get locked() { return __classPrivateFieldGet(this, _MetadataBlock_locked_accessor_storage, "f"); }
+        set locked(value) { __classPrivateFieldSet(this, _MetadataBlock_locked_accessor_storage, value, "f"); }
+        /**
+         * Wait for the block to be unlocked.
+         */
+        waitUnlocked(depth = 0) {
+            if (depth > max_lock_attempts)
+                throw crit(withErrno('EBUSY', `sbfs: exceeded max attempts waiting for metadata block at ${this.offsetHex} to be unlocked`));
+            const i = this.length - 1;
+            if (!Atomics.load(this, i))
+                return;
+            switch (Atomics.wait(this, i, 1)) {
+                case 'ok':
+                    break;
+                case 'not-equal':
+                    depth++;
+                    err(`sbfs: waiting for metadata block at ${this.offsetHex} to be unlocked (${depth}/${max_lock_attempts})`);
+                    return this.waitUnlocked(depth);
+                case 'timed-out':
+                    throw crit(withErrno('EBUSY', `sbfs: timed out waiting for metadata block at ${this.offsetHex} to be unlocked`));
+            }
+        }
+        lock() {
+            this.waitUnlocked();
+            const i = offsetof(this, 'locked');
+            Atomics.store(this, i, 1);
+            const release = () => {
+                Atomics.store(this, i, 0);
+                Atomics.notify(this, i, 1);
+            };
+            release[Symbol.dispose] = release;
+            return release;
+        }
+        constructor() {
+            super(...arguments);
+            _MetadataBlock_checksum_accessor_storage.set(this, __runInitializers(this, _checksum_initializers, void 0));
+            _MetadataBlock_timestamp_accessor_storage.set(this, (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _timestamp_initializers, BigInt(Date.now()))));
+            _MetadataBlock_previous_offset_accessor_storage.set(this, (__runInitializers(this, _timestamp_extraInitializers), __runInitializers(this, _previous_offset_initializers, void 0)));
+            this._previous = __runInitializers(this, _previous_offset_extraInitializers);
+            _MetadataBlock_items_accessor_storage.set(this, __runInitializers(this, _items_initializers, void 0));
+            _MetadataBlock_locked_accessor_storage.set(this, (__runInitializers(this, _items_extraInitializers), __runInitializers(this, _locked_initializers, void 0)));
+            __runInitializers(this, _locked_extraInitializers);
+        }
     };
+    _MetadataBlock_checksum_accessor_storage = new WeakMap();
+    _MetadataBlock_timestamp_accessor_storage = new WeakMap();
+    _MetadataBlock_previous_offset_accessor_storage = new WeakMap();
+    _MetadataBlock_items_accessor_storage = new WeakMap();
+    _MetadataBlock_locked_accessor_storage = new WeakMap();
     __setFunctionName(_classThis, "MetadataBlock");
     (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
         _checksum_decorators = [(_a = t).uint32.bind(_a)];
-        _timestamp_decorators = [(_b = t).uint32.bind(_b)];
-        _previous_offset__decorators = [(_c = t).uint32.bind(_c)];
-        _previous_offset_decorators = [(_d = t).uint32.bind(_d)];
-        _entries_decorators = [member(MetadataEntry, entries_per_block)];
-        __esDecorate(null, null, _checksum_decorators, { kind: "field", 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(null, null, _timestamp_decorators, { kind: "field", name: "timestamp", static: false, private: false, access: { has: obj => "timestamp" in obj, get: obj => obj.timestamp, set: (obj, value) => { obj.timestamp = value; } }, metadata: _metadata }, _timestamp_initializers, _timestamp_extraInitializers);
-        __esDecorate(null, null, _previous_offset__decorators, { kind: "field", name: "previous_offset_", static: false, private: false, access: { has: obj => "previous_offset_" in obj, get: obj => obj.previous_offset_, set: (obj, value) => { obj.previous_offset_ = value; } }, metadata: _metadata }, _previous_offset__initializers, _previous_offset__extraInitializers);
-        __esDecorate(null, null, _previous_offset_decorators, { kind: "field", name: "previous_offset", static: false, private: false, access: { has: obj => "previous_offset" in obj, get: obj => obj.previous_offset, set: (obj, value) => { obj.previous_offset = value; } }, metadata: _metadata }, _previous_offset_initializers, _previous_offset_extraInitializers);
-        __esDecorate(null, null, _entries_decorators, { kind: "field", name: "entries", static: false, private: false, access: { has: obj => "entries" in obj, get: obj => obj.entries, set: (obj, value) => { obj.entries = value; } }, metadata: _metadata }, _entries_initializers, _entries_extraInitializers);
+        _timestamp_decorators = [(_b = t).uint64.bind(_b)];
+        _previous_offset_decorators = [(_c = t).uint32.bind(_c)];
+        _items_decorators = [field(MetadataEntry, { length: entries_per_block })];
+        _locked_decorators = [(_d = t).int32.bind(_d)];
+        __esDecorate(_classThis, 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(_classThis, null, _timestamp_decorators, { kind: "accessor", name: "timestamp", static: false, private: false, access: { has: obj => "timestamp" in obj, get: obj => obj.timestamp, set: (obj, value) => { obj.timestamp = value; } }, metadata: _metadata }, _timestamp_initializers, _timestamp_extraInitializers);
+        __esDecorate(_classThis, null, _previous_offset_decorators, { kind: "accessor", name: "previous_offset", static: false, private: false, access: { has: obj => "previous_offset" in obj, get: obj => obj.previous_offset, set: (obj, value) => { obj.previous_offset = value; } }, metadata: _metadata }, _previous_offset_initializers, _previous_offset_extraInitializers);
+        __esDecorate(_classThis, null, _items_decorators, { kind: "accessor", name: "items", static: false, private: false, access: { has: obj => "items" in obj, get: obj => obj.items, set: (obj, value) => { obj.items = value; } }, metadata: _metadata }, _items_initializers, _items_extraInitializers);
+        __esDecorate(_classThis, null, _locked_decorators, { kind: "accessor", name: "locked", static: false, private: false, access: { has: obj => "locked" in obj, get: obj => obj.locked, set: (obj, value) => { obj.locked = value; } }, metadata: _metadata }, _locked_initializers, _locked_extraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         MetadataBlock = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -178,16 +336,19 @@ let MetadataBlock = (() => {
     })();
     return MetadataBlock = _classThis;
 })();
-const sb_magic = 0x7a2e7362; // 'z.sb'
+export { MetadataBlock };
+const sb_magic = 0x62732e7a; // 'z.sb'
 /**
  * The super block structure for a single-buffer file system
  */
 let SuperBlock = (() => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-    let _classDecorators = [struct()];
+    var _SuperBlock_checksum_accessor_storage, _SuperBlock_magic_accessor_storage, _SuperBlock_version_accessor_storage, _SuperBlock_inode_format_accessor_storage, _SuperBlock_flags_accessor_storage, _SuperBlock_used_bytes_accessor_storage, _SuperBlock_total_bytes_accessor_storage, _SuperBlock_uuid_accessor_storage, _SuperBlock_metadata_block_size_accessor_storage, _SuperBlock_metadata_offset__accessor_storage, _SuperBlock_metadata_offset_accessor_storage, _SuperBlock_label_accessor_storage, _SuperBlock__padding_accessor_storage;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    let _classDecorators = [struct(packed)];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
+    let _classSuper = BufferView;
     let _checksum_decorators;
     let _checksum_initializers = [];
     let _checksum_extraInitializers = [];
@@ -227,60 +388,97 @@ let SuperBlock = (() => {
     let __padding_decorators;
     let __padding_initializers = [];
     let __padding_extraInitializers = [];
-    var SuperBlock = _classThis = class {
-        constructor(store = _throw(new ErrnoError(Errno.EINVAL, 'Super block must be initialized with a store'))) {
-            this.store = store;
-            /**
-             * The crc32c checksum for the super block.
-             * @privateRemarks Keep this first!
-             */
-            this.checksum = __runInitializers(this, _checksum_initializers, 0);
-            /** Signature for the superblock. */
-            this.magic = (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _magic_initializers, sb_magic));
-            /** The version of the on-disk format */
-            this.version = (__runInitializers(this, _magic_extraInitializers), __runInitializers(this, _version_initializers, 1));
-            /** Which format of `Inode` is used */
-            this.inode_format = (__runInitializers(this, _version_extraInitializers), __runInitializers(this, _inode_format_initializers, _inode_version));
-            /** Flags for the file system. Currently unused */
-            this.flags = (__runInitializers(this, _inode_format_extraInitializers), __runInitializers(this, _flags_initializers, 0));
-            /** The number of used bytes, including the super block and metadata */
-            this.used_bytes = (__runInitializers(this, _flags_extraInitializers), __runInitializers(this, _used_bytes_initializers, BigInt(0)));
-            /** The total size of the entire file system, including the super block and metadata */
-            this.total_bytes = (__runInitializers(this, _used_bytes_extraInitializers), __runInitializers(this, _total_bytes_initializers, BigInt(0)));
-            /** A UUID for this file system */
-            this.uuid = (__runInitializers(this, _total_bytes_extraInitializers), __runInitializers(this, _uuid_initializers, BigInt(0)));
-            /**
-             * The size in bytes of a metadata block.
-             * Not currently configurable.
-             */
-            this.metadata_block_size = (__runInitializers(this, _uuid_extraInitializers), __runInitializers(this, _metadata_block_size_initializers, sizeof(MetadataBlock)));
-            /** Reserved for 64-bit offset expansion */
-            this.metadata_offset_ = (__runInitializers(this, _metadata_block_size_extraInitializers), __runInitializers(this, _metadata_offset__initializers, 0));
-            /** Offset of the current metadata block */
-            this.metadata_offset = (__runInitializers(this, _metadata_offset__extraInitializers), __runInitializers(this, _metadata_offset_initializers, 0));
+    var SuperBlock = _classThis = class extends _classSuper {
+        constructor(...args) {
+            super(...args);
+            _SuperBlock_checksum_accessor_storage.set(this, __runInitializers(this, _checksum_initializers, void 0));
+            _SuperBlock_magic_accessor_storage.set(this, (__runInitializers(this, _checksum_extraInitializers), __runInitializers(this, _magic_initializers, void 0)));
+            _SuperBlock_version_accessor_storage.set(this, (__runInitializers(this, _magic_extraInitializers), __runInitializers(this, _version_initializers, void 0)));
+            _SuperBlock_inode_format_accessor_storage.set(this, (__runInitializers(this, _version_extraInitializers), __runInitializers(this, _inode_format_initializers, void 0)));
+            _SuperBlock_flags_accessor_storage.set(this, (__runInitializers(this, _inode_format_extraInitializers), __runInitializers(this, _flags_initializers, void 0)));
+            _SuperBlock_used_bytes_accessor_storage.set(this, (__runInitializers(this, _flags_extraInitializers), __runInitializers(this, _used_bytes_initializers, void 0)));
+            _SuperBlock_total_bytes_accessor_storage.set(this, (__runInitializers(this, _used_bytes_extraInitializers), __runInitializers(this, _total_bytes_initializers, void 0)));
+            _SuperBlock_uuid_accessor_storage.set(this, (__runInitializers(this, _total_bytes_extraInitializers), __runInitializers(this, _uuid_initializers, void 0)));
+            _SuperBlock_metadata_block_size_accessor_storage.set(this, (__runInitializers(this, _uuid_extraInitializers), __runInitializers(this, _metadata_block_size_initializers, void 0)));
+            _SuperBlock_metadata_offset__accessor_storage.set(this, (__runInitializers(this, _metadata_block_size_extraInitializers), __runInitializers(this, _metadata_offset__initializers, void 0)));
+            _SuperBlock_metadata_offset_accessor_storage.set(this, (__runInitializers(this, _metadata_offset__extraInitializers), __runInitializers(this, _metadata_offset_initializers, void 0)));
             this.metadata = __runInitializers(this, _metadata_offset_extraInitializers);
-            /** An optional label for the file system */
-            this.label = __runInitializers(this, _label_initializers, '');
-            /** Padded to 256 bytes */
-            this._padding = (__runInitializers(this, _label_extraInitializers), __runInitializers(this, __padding_initializers, new Array(132).fill(0)));
+            _SuperBlock_label_accessor_storage.set(this, __runInitializers(this, _label_initializers, void 0));
+            _SuperBlock__padding_accessor_storage.set(this, (__runInitializers(this, _label_extraInitializers), __runInitializers(this, __padding_initializers, void 0)));
             __runInitializers(this, __padding_extraInitializers);
-            this.store = store;
-            if (store._view.getUint32(offsetof(SuperBlock, 'magic'), true) != sb_magic) {
-                warn('SingleBuffer: Invalid magic value, assuming this is a fresh super block');
-                this.metadata = new MetadataBlock(this);
-                this.metadata.offset = sizeof(SuperBlock);
-                this.metadata_offset = this.metadata.offset;
-                this.used_bytes = BigInt(sizeof(SuperBlock) + sizeof(MetadataBlock));
-                this.total_bytes = BigInt(store._buffer.byteLength);
-                store._write(this);
-                store._write(this.metadata);
+            if (this.magic != sb_magic) {
+                warn('sbfs: Invalid magic value, assuming this is a fresh super block');
+                const md = new MetadataBlock(this.buffer, sizeof(SuperBlock));
+                Object.assign(this, {
+                    metadata: md,
+                    metadata_offset: md.byteOffset,
+                    used_bytes: BigInt(sizeof(SuperBlock) + sizeof(MetadataBlock)),
+                    total_bytes: BigInt(this.buffer.byteLength),
+                    magic: sb_magic,
+                    version: 1,
+                    inode_format: _inode_version,
+                    metadata_block_size: sizeof(MetadataBlock),
+                    uuid: encodeUUID(crypto.randomUUID()),
+                });
+                _update(this);
+                _update(md);
                 return;
             }
-            deserialize(this, store._buffer.subarray(0, sizeof(SuperBlock)));
-            if (!checksumMatches(this))
-                throw crit(new ErrnoError(Errno.EIO, 'SingleBuffer: Checksum mismatch for super block!'));
-            this.metadata = new MetadataBlock(this, this.metadata_offset);
+            if (this.checksum !== checksum(this))
+                throw crit(withErrno('EIO', 'sbfs: checksum mismatch for super block'));
+            this.metadata = new MetadataBlock(this.buffer, this.metadata_offset);
+            if (this.metadata.checksum !== checksum(this.metadata))
+                throw crit(withErrno('EIO', `sbfs: checksum mismatch for metadata block (saved ${this.metadata.checksum.toString(16).padStart(8, '0')}, computed ${checksum(this.metadata).toString(16).padStart(8, '0')})`));
+            if (this.inode_format != _inode_version)
+                throw crit(withErrno('EIO', 'sbfs: inode format mismatch'));
+            if (this.metadata_block_size != sizeof(MetadataBlock))
+                throw crit(withErrno('EIO', 'sbfs: metadata block size mismatch'));
         }
+        /**
+         * The crc32c checksum for the super block.
+         * @privateRemarks Keep this first!
+         */
+        get checksum() { return __classPrivateFieldGet(this, _SuperBlock_checksum_accessor_storage, "f"); }
+        set checksum(value) { __classPrivateFieldSet(this, _SuperBlock_checksum_accessor_storage, value, "f"); }
+        /** Signature for the superblock. */
+        get magic() { return __classPrivateFieldGet(this, _SuperBlock_magic_accessor_storage, "f"); }
+        set magic(value) { __classPrivateFieldSet(this, _SuperBlock_magic_accessor_storage, value, "f"); }
+        /** The version of the on-disk format */
+        get version() { return __classPrivateFieldGet(this, _SuperBlock_version_accessor_storage, "f"); }
+        set version(value) { __classPrivateFieldSet(this, _SuperBlock_version_accessor_storage, value, "f"); }
+        /** Which format of `Inode` is used */
+        get inode_format() { return __classPrivateFieldGet(this, _SuperBlock_inode_format_accessor_storage, "f"); }
+        set inode_format(value) { __classPrivateFieldSet(this, _SuperBlock_inode_format_accessor_storage, value, "f"); }
+        /** Flags for the file system. Currently unused */
+        get flags() { return __classPrivateFieldGet(this, _SuperBlock_flags_accessor_storage, "f"); }
+        set flags(value) { __classPrivateFieldSet(this, _SuperBlock_flags_accessor_storage, value, "f"); }
+        /** The number of used bytes, including the super block and metadata */
+        get used_bytes() { return __classPrivateFieldGet(this, _SuperBlock_used_bytes_accessor_storage, "f"); }
+        set used_bytes(value) { __classPrivateFieldSet(this, _SuperBlock_used_bytes_accessor_storage, value, "f"); }
+        /** The total size of the entire file system, including the super block and metadata */
+        get total_bytes() { return __classPrivateFieldGet(this, _SuperBlock_total_bytes_accessor_storage, "f"); }
+        set total_bytes(value) { __classPrivateFieldSet(this, _SuperBlock_total_bytes_accessor_storage, value, "f"); }
+        /** A UUID for this file system */
+        get uuid() { return __classPrivateFieldGet(this, _SuperBlock_uuid_accessor_storage, "f"); }
+        set uuid(value) { __classPrivateFieldSet(this, _SuperBlock_uuid_accessor_storage, value, "f"); }
+        /**
+         * The size in bytes of a metadata block.
+         * Not currently configurable.
+         */
+        get metadata_block_size() { return __classPrivateFieldGet(this, _SuperBlock_metadata_block_size_accessor_storage, "f"); }
+        set metadata_block_size(value) { __classPrivateFieldSet(this, _SuperBlock_metadata_block_size_accessor_storage, value, "f"); }
+        /** Reserved for 64-bit offset expansion */
+        get metadata_offset_() { return __classPrivateFieldGet(this, _SuperBlock_metadata_offset__accessor_storage, "f"); }
+        set metadata_offset_(value) { __classPrivateFieldSet(this, _SuperBlock_metadata_offset__accessor_storage, value, "f"); }
+        /** Offset of the current metadata block */
+        get metadata_offset() { return __classPrivateFieldGet(this, _SuperBlock_metadata_offset_accessor_storage, "f"); }
+        set metadata_offset(value) { __classPrivateFieldSet(this, _SuperBlock_metadata_offset_accessor_storage, value, "f"); }
+        /** An optional label for the file system */
+        get label() { return __classPrivateFieldGet(this, _SuperBlock_label_accessor_storage, "f"); }
+        set label(value) { __classPrivateFieldSet(this, _SuperBlock_label_accessor_storage, value, "f"); }
+        /** Padded to 256 bytes */
+        get _padding() { return __classPrivateFieldGet(this, _SuperBlock__padding_accessor_storage, "f"); }
+        set _padding(value) { __classPrivateFieldSet(this, _SuperBlock__padding_accessor_storage, value, "f"); }
         /**
          * Rotate out the current metadata block.
          * Allocates a new metadata block, moves the current one to backup,
@@ -288,14 +486,13 @@ let SuperBlock = (() => {
          * @returns the new metadata block
          */
         rotateMetadata() {
-            const metadata = new MetadataBlock(this);
-            metadata.offset = Number(this.used_bytes);
+            const metadata = new MetadataBlock(this.buffer, Number(this.used_bytes));
             metadata.previous_offset = this.metadata_offset;
             this.metadata = metadata;
-            this.metadata_offset = metadata.offset;
-            this.store._write(metadata);
+            this.metadata_offset = metadata.byteOffset;
+            _update(metadata);
             this.used_bytes += BigInt(sizeof(MetadataBlock));
-            this.store._write(this);
+            _update(this);
             return metadata;
         }
         /**
@@ -308,9 +505,9 @@ let SuperBlock = (() => {
             if (offset + length > this.total_bytes || offset < sizeof(SuperBlock))
                 return false;
             for (let block = this.metadata; block; block = block.previous) {
-                if (offset < block.offset + sizeof(MetadataBlock) && offset + length > block.offset)
+                if (offset < block.byteOffset + sizeof(MetadataBlock) && offset + length > block.byteOffset)
                     return false;
-                for (const entry of block.entries) {
+                for (const entry of block.items) {
                     if (!entry.offset)
                         continue;
                     if ((offset >= entry.offset && offset < entry.offset + entry.size)
@@ -323,9 +520,23 @@ let SuperBlock = (() => {
             return true;
         }
     };
+    _SuperBlock_checksum_accessor_storage = new WeakMap();
+    _SuperBlock_magic_accessor_storage = new WeakMap();
+    _SuperBlock_version_accessor_storage = new WeakMap();
+    _SuperBlock_inode_format_accessor_storage = new WeakMap();
+    _SuperBlock_flags_accessor_storage = new WeakMap();
+    _SuperBlock_used_bytes_accessor_storage = new WeakMap();
+    _SuperBlock_total_bytes_accessor_storage = new WeakMap();
+    _SuperBlock_uuid_accessor_storage = new WeakMap();
+    _SuperBlock_metadata_block_size_accessor_storage = new WeakMap();
+    _SuperBlock_metadata_offset__accessor_storage = new WeakMap();
+    _SuperBlock_metadata_offset_accessor_storage = new WeakMap();
+    _SuperBlock_label_accessor_storage = new WeakMap();
+    _SuperBlock__padding_accessor_storage = new WeakMap();
     __setFunctionName(_classThis, "SuperBlock");
     (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
         _checksum_decorators = [(_a = t).uint32.bind(_a)];
         _magic_decorators = [(_b = t).uint32.bind(_b)];
         _version_decorators = [(_c = t).uint16.bind(_c)];
@@ -333,25 +544,25 @@ let SuperBlock = (() => {
         _flags_decorators = [(_e = t).uint32.bind(_e)];
         _used_bytes_decorators = [(_f = t).uint64.bind(_f)];
         _total_bytes_decorators = [(_g = t).uint64.bind(_g)];
-        _uuid_decorators = [(_h = t).uint128.bind(_h)];
-        _metadata_block_size_decorators = [(_j = t).uint32.bind(_j)];
-        _metadata_offset__decorators = [(_k = t).uint32.bind(_k)];
-        _metadata_offset_decorators = [(_l = t).uint32.bind(_l)];
+        _uuid_decorators = [t.uint8(16)];
+        _metadata_block_size_decorators = [(_h = t).uint32.bind(_h)];
+        _metadata_offset__decorators = [(_j = t).uint32.bind(_j)];
+        _metadata_offset_decorators = [(_k = t).uint32.bind(_k)];
         _label_decorators = [t.char(64)];
         __padding_decorators = [t.char(132)];
-        __esDecorate(null, null, _checksum_decorators, { kind: "field", 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(null, null, _magic_decorators, { kind: "field", 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(null, null, _version_decorators, { kind: "field", 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(null, null, _inode_format_decorators, { kind: "field", 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(null, null, _flags_decorators, { kind: "field", name: "flags", static: false, private: false, access: { has: obj => "flags" in obj, get: obj => obj.flags, set: (obj, value) => { obj.flags = value; } }, metadata: _metadata }, _flags_initializers, _flags_extraInitializers);
-        __esDecorate(null, null, _used_bytes_decorators, { kind: "field", name: "used_bytes", static: false, private: false, access: { has: obj => "used_bytes" in obj, get: obj => obj.used_bytes, set: (obj, value) => { obj.used_bytes = value; } }, metadata: _metadata }, _used_bytes_initializers, _used_bytes_extraInitializers);
-        __esDecorate(null, null, _total_bytes_decorators, { kind: "field", 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(null, null, _uuid_decorators, { kind: "field", 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(null, null, _metadata_block_size_decorators, { kind: "field", name: "metadata_block_size", static: false, private: false, access: { has: obj => "metadata_block_size" in obj, get: obj => obj.metadata_block_size, set: (obj, value) => { obj.metadata_block_size = value; } }, metadata: _metadata }, _metadata_block_size_initializers, _metadata_block_size_extraInitializers);
-        __esDecorate(null, null, _metadata_offset__decorators, { kind: "field", name: "metadata_offset_", static: false, private: false, access: { has: obj => "metadata_offset_" in obj, get: obj => obj.metadata_offset_, set: (obj, value) => { obj.metadata_offset_ = value; } }, metadata: _metadata }, _metadata_offset__initializers, _metadata_offset__extraInitializers);
-        __esDecorate(null, null, _metadata_offset_decorators, { kind: "field", name: "metadata_offset", static: false, private: false, access: { has: obj => "metadata_offset" in obj, get: obj => obj.metadata_offset, set: (obj, value) => { obj.metadata_offset = value; } }, metadata: _metadata }, _metadata_offset_initializers, _metadata_offset_extraInitializers);
-        __esDecorate(null, null, _label_decorators, { kind: "field", 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(null, null, __padding_decorators, { kind: "field", 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(_classThis, 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(_classThis, 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(_classThis, 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(_classThis, 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(_classThis, null, _flags_decorators, { kind: "accessor", name: "flags", static: false, private: false, access: { has: obj => "flags" in obj, get: obj => obj.flags, set: (obj, value) => { obj.flags = value; } }, metadata: _metadata }, _flags_initializers, _flags_extraInitializers);
+        __esDecorate(_classThis, null, _used_bytes_decorators, { kind: "accessor", name: "used_bytes", static: false, private: false, access: { has: obj => "used_bytes" in obj, get: obj => obj.used_bytes, set: (obj, value) => { obj.used_bytes = value; } }, metadata: _metadata }, _used_bytes_initializers, _used_bytes_extraInitializers);
+        __esDecorate(_classThis, 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(_classThis, 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(_classThis, null, _metadata_block_size_decorators, { kind: "accessor", name: "metadata_block_size", static: false, private: false, access: { has: obj => "metadata_block_size" in obj, get: obj => obj.metadata_block_size, set: (obj, value) => { obj.metadata_block_size = value; } }, metadata: _metadata }, _metadata_block_size_initializers, _metadata_block_size_extraInitializers);
+        __esDecorate(_classThis, null, _metadata_offset__decorators, { kind: "accessor", name: "metadata_offset_", static: false, private: false, access: { has: obj => "metadata_offset_" in obj, get: obj => obj.metadata_offset_, set: (obj, value) => { obj.metadata_offset_ = value; } }, metadata: _metadata }, _metadata_offset__initializers, _metadata_offset__extraInitializers);
+        __esDecorate(_classThis, null, _metadata_offset_decorators, { kind: "accessor", name: "metadata_offset", static: false, private: false, access: { has: obj => "metadata_offset" in obj, get: obj => obj.metadata_offset, set: (obj, value) => { obj.metadata_offset = value; } }, metadata: _metadata }, _metadata_offset_initializers, _metadata_offset_extraInitializers);
+        __esDecorate(_classThis, 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(_classThis, 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(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 });
@@ -359,120 +570,150 @@ let SuperBlock = (() => {
     })();
     return SuperBlock = _classThis;
 })();
-function checksumMatches(value) {
-    const buffer = serialize(value);
-    const computed = crc32c(buffer.subarray(4)); // note we don't include the checksum when computing a new one.
-    return value.checksum === computed;
+export { SuperBlock };
+/**
+ * Compute the checksum for a super block or metadata block.
+ * Note we don't include the checksum when computing a new one.
+ */
+function checksum(value) {
+    return crc32c(new Uint8Array(value.buffer, value.byteOffset + 4, sizeof(value) - 4));
+}
+/**
+ * Update a block's checksum and timestamp.
+ * @internal @hidden
+ */
+function _update(value) {
+    if (value instanceof MetadataBlock)
+        value.timestamp = BigInt(Date.now());
+    value.checksum = checksum(value);
 }
 /**
  *
  * @category Stores and Transactions
  */
-export class SingleBufferStore {
+export class SingleBufferStore extends BufferView {
     get uuid() {
-        return stringifyUUID(this.superblock.uuid);
+        return decodeUUID(this.superblock.uuid);
     }
-    constructor(buffer) {
+    constructor(...args) {
+        super(...args);
         this.flags = [];
         this.name = 'sbfs';
         this.type = 0x73626673; // 'sbfs'
-        if (buffer.byteLength < sizeof(SuperBlock) + sizeof(MetadataBlock))
-            throw crit(new ErrnoError(Errno.EINVAL, 'SingleBuffer: Buffer is too small for a file system'));
-        this._view = !ArrayBuffer.isView(buffer) ? new DataView(buffer) : new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        this._buffer = !ArrayBuffer.isView(buffer) ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        this.superblock = new SuperBlock(this);
-    }
-    /**
-     * Update a block's checksum and write it to the store's buffer.
-     * @internal @hidden
-     */
-    _write(value) {
-        value.checksum = crc32c(serialize(value).subarray(4));
-        const offset = 'offset' in value ? value.offset : 0;
-        this._buffer.set(serialize(value), offset);
+        if (this.byteLength < sizeof(SuperBlock) + sizeof(MetadataBlock))
+            throw crit(withErrno('EINVAL', 'sbfs: Buffer is too small for a file system'));
+        this._view = new DataView(this.buffer, this.byteOffset, this.byteLength);
+        this._u8 = new Uint8Array(this.buffer, this.byteOffset, this.byteLength);
+        this.superblock = new SuperBlock(this.buffer, this.byteOffset);
     }
-    keys() {
+    *keys() {
         const keys = new Set();
         for (let block = this.superblock.metadata; block; block = block.previous) {
-            for (const entry of block.entries)
-                if (entry.offset)
-                    keys.add(entry.id);
+            block.waitUnlocked();
+            for (const entry of block.items) {
+                if (!entry.offset || keys.has(entry.id))
+                    continue;
+                keys.add(entry.id);
+                yield entry.id;
+            }
         }
-        return keys;
     }
     get(id) {
         for (let block = this.superblock.metadata; block; block = block.previous) {
-            for (const entry of block.entries) {
-                if (entry.offset && entry.id == id) {
-                    return this._buffer.subarray(entry.offset, entry.offset + entry.size);
-                }
+            block.waitUnlocked();
+            for (const entry of block.items) {
+                if (!entry.offset || entry.id != id)
+                    continue;
+                const off = this.byteOffset + entry.offset;
+                return new Uint8Array(this.buffer.slice(off, off + entry.size));
             }
         }
     }
     set(id, data) {
-        for (let block = this.superblock.metadata; block; block = block.previous) {
-            for (const entry of block.entries) {
-                if (!entry.offset || entry.id != id)
-                    continue;
-                if (data.length <= entry.size) {
-                    this._buffer.set(data, entry.offset);
-                    if (data.length < entry.size) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (id === 0 && data.length < sizeof(Inode))
+                throw alert(withErrno('EIO', `sbfs: tried to set ${data.length} bytes for id 0!`));
+            for (let block = this.superblock.metadata; block; block = block.previous) {
+                block.waitUnlocked();
+                for (const entry of block.items) {
+                    const env_2 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        if (!entry.offset || entry.id != id)
+                            continue;
+                        const lock = __addDisposableResource(env_2, block.lock(), false);
+                        if (data.length == entry.size) {
+                            this._u8.set(data, entry.offset);
+                            return;
+                        }
+                        if (data.length < entry.size || this.superblock.isUnused(entry.offset, data.length)) {
+                            this._u8.set(data, entry.offset);
+                            entry.size = data.length;
+                            _update(block);
+                            return;
+                        }
+                        entry.offset = Number(this.superblock.used_bytes);
                         entry.size = data.length;
-                        this._write(block);
+                        this._u8.set(data, entry.offset);
+                        _update(block);
+                        this.superblock.used_bytes += BigInt(data.length);
+                        _update(this.superblock);
+                        return;
                     }
-                    return;
-                }
-                if (this.superblock.isUnused(entry.offset, data.length)) {
-                    entry.size = data.length;
-                    this._buffer.set(data, entry.offset);
-                    this._write(block);
-                    return;
-                }
-                const used_bytes = Number(this.superblock.used_bytes);
-                for (let block = this.superblock.metadata; block; block = block.previous) {
-                    for (const entry of block.entries) {
-                        if (entry.offset != used_bytes)
-                            continue;
-                        entry.offset += data.length;
-                        this._write(block);
-                        break;
+                    catch (e_1) {
+                        env_2.error = e_1;
+                        env_2.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_2);
                     }
                 }
-                entry.offset = used_bytes;
-                entry.size = data.length;
-                this._buffer.set(data, entry.offset);
-                this._write(block);
-                this.superblock.used_bytes += BigInt(data.length);
-                this._write(this.superblock);
-                return;
             }
+            let entry = Array.from(this.superblock.metadata.items).find(e => !e.offset);
+            if (!entry) {
+                this.superblock.rotateMetadata();
+                entry = this.superblock.metadata.items[0];
+            }
+            const lock = __addDisposableResource(env_1, this.superblock.metadata.lock(), false);
+            const offset = Number(this.superblock.used_bytes);
+            entry.id = id;
+            entry.offset = offset;
+            entry.size = data.length;
+            this._u8.set(data, offset);
+            this.superblock.used_bytes += BigInt(data.length);
+            _update(this.superblock.metadata);
+            _update(this.superblock);
+        }
+        catch (e_2) {
+            env_1.error = e_2;
+            env_1.hasError = true;
         }
-        let entry = this.superblock.metadata.entries.find(e => !e.offset);
-        if (!entry) {
-            this.superblock.rotateMetadata();
-            entry = this.superblock.metadata.entries[0];
+        finally {
+            __disposeResources(env_1);
         }
-        const offset = Number(this.superblock.used_bytes);
-        entry.id = id;
-        entry.offset = offset;
-        entry.size = data.length;
-        this._buffer.set(data, offset);
-        this.superblock.used_bytes += BigInt(data.length);
-        this._write(this.superblock.metadata);
-        this._write(this.superblock);
     }
     delete(id) {
         for (let block = this.superblock.metadata; block; block = block.previous) {
-            for (const entry of block.entries) {
+            block.waitUnlocked();
+            for (const entry of block.items) {
                 if (entry.id != id)
                     continue;
                 entry.offset = 0;
                 entry.size = 0;
-                this._write(block);
+                entry.id = 0;
+                _update(block);
                 return;
             }
         }
     }
+    get fs() {
+        return this._fs;
+    }
+    set fs(fs) {
+        if (this.buffer instanceof SharedArrayBuffer)
+            fs === null || fs === void 0 ? void 0 : fs.attributes.set('no_id_tables', true);
+        this._fs = fs;
+    }
     sync() {
         return Promise.resolve();
     }
@@ -491,8 +732,10 @@ const _SingleBuffer = {
     options: {
         buffer: { type: 'object', required: true },
     },
-    create({ buffer }) {
-        const fs = new StoreFS(new SingleBufferStore(buffer));
+    create(opt) {
+        const fs = new StoreFS(ArrayBuffer.isView(opt.buffer)
+            ? new SingleBufferStore(opt.buffer.buffer, opt.buffer.byteOffset, opt.buffer.byteLength)
+            : new SingleBufferStore(opt.buffer));
         fs.checkRootSync();
         return fs;
     },