@zenfs/core 1.11.4 → 2.1.0

package/dist/backends/single_buffer.d.ts

@@ -1,81 +1,94 @@
+import { type StructArray } from 'memium';
+import type { UUID } from 'node:crypto';
+import { BufferView } from 'utilium/buffer.js';
 import type { UsageInfo } from '../internal/filesystem.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
 import type { Store } from './store/store.js';
-declare class MetadataEntry {
+type Lock = Disposable & (() => void);
+declare class MetadataEntry extends BufferView {
     /** Inode or data ID */
-    id: number;
+    accessor id: number;
     /** Reserved for 64-bit offset expansion */
-    protected offset_: number;
+    protected accessor offset_: number;
     /** Offset into the buffer the data is stored at. */
-    offset: number;
+    accessor offset: number;
     /** The size of the data */
-    size: number;
+    accessor size: number;
+    toString(): string;
 }
 /**
  * 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.
  */
-declare class MetadataBlock {
-    protected readonly superblock: SuperBlock;
-    offset: number;
-    constructor(superblock: SuperBlock, offset?: number);
+export declare class MetadataBlock extends Int32Array<ArrayBufferLike> {
+    readonly ['constructor']: typeof MetadataBlock;
     /**
      * The crc32c checksum for the metadata block.
      * @privateRemarks Keep this first!
      */
-    checksum: number;
+    accessor checksum: number;
     /** The (last) time this metadata block was updated */
-    timestamp: number;
-    /** Reserved for 64-bit offset expansion */
-    protected previous_offset_: number;
+    accessor timestamp: bigint;
     /** Offset to the previous metadata block */
-    previous_offset: number;
+    accessor previous_offset: number;
     protected _previous?: MetadataBlock;
     get previous(): MetadataBlock | undefined;
+    protected get offsetHex(): string;
     /** Metadata entries. */
-    entries: MetadataEntry[];
+    accessor items: StructArray<MetadataEntry>;
+    toString(long?: boolean): string;
+    /**
+     * If non-zero, this block is locked for writing.
+     * Note a int32 is used for `Atomics.wait`
+     */
+    accessor locked: number;
+    /**
+     * Wait for the block to be unlocked.
+     */
+    waitUnlocked(depth?: number): void;
+    lock(): Lock;
 }
 /**
  * The super block structure for a single-buffer file system
  */
-declare class SuperBlock {
-    readonly store: SingleBufferStore;
-    constructor(store: SingleBufferStore);
+export declare class SuperBlock extends BufferView {
+    readonly ['constructor']: typeof SuperBlock;
+    constructor(...args: ConstructorParameters<typeof BufferView>);
     /**
      * The crc32c checksum for the super block.
      * @privateRemarks Keep this first!
      */
-    checksum: number;
+    accessor checksum: number;
     /** Signature for the superblock. */
-    magic: number;
+    accessor magic: number;
     /** The version of the on-disk format */
-    version: number;
+    accessor version: number;
     /** Which format of `Inode` is used */
-    inode_format: number;
+    accessor inode_format: number;
     /** Flags for the file system. Currently unused */
-    flags: number;
+    accessor flags: number;
     /** The number of used bytes, including the super block and metadata */
-    used_bytes: bigint;
+    accessor used_bytes: bigint;
     /** The total size of the entire file system, including the super block and metadata */
-    total_bytes: bigint;
-    /** An ID for this file system */
-    id: bigint;
+    accessor total_bytes: bigint;
+    /** A UUID for this file system */
+    accessor uuid: Uint8Array;
     /**
      * The size in bytes of a metadata block.
      * Not currently configurable.
      */
-    metadata_block_size: number;
+    accessor metadata_block_size: number;
     /** Reserved for 64-bit offset expansion */
-    protected metadata_offset_: number;
+    protected accessor metadata_offset_: number;
     /** Offset of the current metadata block */
-    metadata_offset: number;
+    accessor metadata_offset: number;
     metadata: MetadataBlock;
     /** An optional label for the file system */
-    label: string;
+    accessor label: Uint8Array;
     /** Padded to 256 bytes */
-    _padding: number[];
+    accessor _padding: Uint8Array;
     /**
      * Rotate out the current metadata block.
      * Allocates a new metadata block, moves the current one to backup,
@@ -93,30 +106,25 @@ declare class SuperBlock {
  *
  * @category Stores and Transactions
  */
-export declare class SingleBufferStore implements SyncMapStore {
+export declare class SingleBufferStore extends BufferView implements SyncMapStore {
     readonly flags: readonly [];
     readonly name = "sbfs";
-    readonly id = 1935828595;
+    readonly type = 1935828595;
+    get uuid(): UUID;
     protected superblock: SuperBlock;
     /**
      * @internal @hidden
      */
-    readonly _view: DataView;
-    /**
-     * @internal @hidden
-     */
-    readonly _buffer: Uint8Array;
-    constructor(buffer: ArrayBufferLike | ArrayBufferView);
-    /**
-     * Update a block's checksum and write it to the store's buffer.
-     * @internal @hidden
-     */
-    _write(value: SuperBlock | MetadataBlock): void;
+    protected readonly _view: DataView;
+    protected readonly _u8: Uint8Array;
+    constructor(...args: ConstructorParameters<typeof BufferView>);
     keys(): Iterable<number>;
     get(id: number): Uint8Array | undefined;
     set(id: number, data: Uint8Array): void;
     delete(id: number): void;
-    _fs?: StoreFS<Store> | undefined;
+    protected _fs?: StoreFS<Store> | undefined;
+    get fs(): StoreFS<Store> | undefined;
+    set fs(fs: StoreFS<Store> | undefined);
     sync(): Promise<void>;
     usage(): UsageInfo;
     transaction(): SyncMapTransaction;
@@ -136,9 +144,13 @@ declare const _SingleBuffer: {
             readonly required: true;
         };
     };
-    readonly create: ({ buffer }: SingleBufferOptions) => StoreFS<SingleBufferStore>;
+    readonly create: (opt: SingleBufferOptions) => StoreFS<SingleBufferStore>;
 };
 type _SingleBuffer = typeof _SingleBuffer;
+/**
+ * A backend that uses a single buffer for storing data
+ * @category Backends and Configuration
+ */
 export interface SingleBuffer extends _SingleBuffer {
 }
 /**