@zenfs/core 2.3.5 → 2.3.7

package/dist/backends/port.d.ts

@@ -68,7 +68,10 @@ declare const _Port: {
     name: string;
     options: {
         port: {
-            type: string[];
+            type: ({
+                new (): EventTarget;
+                prototype: EventTarget;
+            } | ((e: any) => boolean))[];
             required: true;
         };
         timeout: {

package/dist/backends/port.js

@@ -112,7 +112,12 @@ const _Port = {
     name: 'Port',
     options: {
         port: {
-            type: ['Worker', 'MessagePort', 'WebSocket'],
+            type: [
+                EventTarget,
+                function EventEmitter(e) {
+                    return typeof e == 'object' && 'on' in e;
+                },
+            ],
             required: true,
         },
         timeout: { type: 'number', required: false },

package/dist/backends/single_buffer.d.ts

@@ -1,4 +1,4 @@
-import { type StructArray } from 'memium';
+import type { ArrayOf } from 'memium';
 import type { UUID } from 'node:crypto';
 import { BufferView } from 'utilium/buffer.js';
 import type { UsageInfo } from '../internal/filesystem.js';
@@ -6,7 +6,8 @@ import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
 import type { Store } from './store/store.js';
 type Lock = Disposable & (() => void);
-declare class MetadataEntry extends BufferView {
+declare const MetadataEntry_base: import("memium").StructConstructor<BufferView<any>>;
+declare class MetadataEntry extends MetadataEntry_base {
     /** Inode or data ID */
     accessor id: number;
     /** Reserved for 64-bit offset expansion */
@@ -17,12 +18,13 @@ declare class MetadataEntry extends BufferView {
     accessor size: number;
     toString(): string;
 }
+declare const MetadataBlock_base: import("memium/decorators").StructFromTypedArray<Int32Array<ArrayBuffer>>;
 /**
  * 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.
  */
-export declare class MetadataBlock extends Int32Array<ArrayBufferLike> {
+export declare class MetadataBlock extends MetadataBlock_base<ArrayBufferLike> {
     readonly ['constructor']: typeof MetadataBlock;
     /**
      * The crc32c checksum for the metadata block.
@@ -37,7 +39,7 @@ export declare class MetadataBlock extends Int32Array<ArrayBufferLike> {
     get previous(): MetadataBlock | undefined;
     protected get offsetHex(): string;
     /** Metadata entries. */
-    accessor items: StructArray<MetadataEntry>;
+    accessor items: ArrayOf<MetadataEntry>;
     toString(long?: boolean): string;
     /**
      * If non-zero, this block is locked for writing.
@@ -50,10 +52,11 @@ export declare class MetadataBlock extends Int32Array<ArrayBufferLike> {
     waitUnlocked(depth?: number): void;
     lock(): Lock;
 }
+declare const SuperBlock_base: import("memium/decorators").StructFromTypedArray<BigUint64Array<ArrayBuffer>>;
 /**
  * The super block structure for a single-buffer file system
  */
-export declare class SuperBlock extends BigUint64Array<ArrayBufferLike> {
+export declare class SuperBlock extends SuperBlock_base<ArrayBufferLike> {
     readonly ['constructor']: typeof SuperBlock;
     constructor(...args: ConstructorParameters<typeof BigUint64Array<ArrayBufferLike>>);
     /**

package/dist/backends/single_buffer.js

@@ -86,7 +86,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { withErrno } from 'kerium';
 import { alert, crit, err, warn } from 'kerium/log';
-import { field, offsetof, packed, sizeof, struct, types as t } from 'memium';
+import { array, offsetof, packed, sizeof } from 'memium';
+import { $from, field, struct, types as t } from 'memium/decorators';
 import { BufferView } from 'utilium/buffer.js';
 import { crc32c } from 'utilium/checksum.js';
 import { decodeUUID, encodeUUID } from 'utilium/string.js';
@@ -102,11 +103,11 @@ const { format } = new Intl.NumberFormat('en-US', {
 });
 let MetadataEntry = (() => {
     var _a, _b, _c, _d;
-    let _classDecorators = [struct(packed, { name: 'MetadataEntry' })];
+    let _classDecorators = [struct.packed('MetadataEntry')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _id_decorators;
     let _id_initializers = [];
     let _id_extraInitializers = [];
@@ -177,11 +178,11 @@ const max_lock_attempts = 5;
  */
 let MetadataBlock = (() => {
     var _a, _b, _c, _d;
-    let _classDecorators = [struct(packed, { name: 'MetadataBlock' })];
+    let _classDecorators = [struct.packed('MetadataBlock')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = Int32Array;
+    let _classSuper = $from.typed(Int32Array);
     let _checksum_decorators;
     let _checksum_initializers = [];
     let _checksum_extraInitializers = [];
@@ -204,7 +205,7 @@ let MetadataBlock = (() => {
             _checksum_decorators = [(_a = t).uint32.bind(_a)];
             _timestamp_decorators = [(_b = t).uint64.bind(_b)];
             _previous_offset_decorators = [(_c = t).uint32.bind(_c)];
-            _items_decorators = [field(MetadataEntry, { length: entries_per_block })];
+            _items_decorators = [field(array(MetadataEntry, entries_per_block))];
             _locked_decorators = [(_d = t).int32.bind(_d)];
             __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, _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);
@@ -319,11 +320,11 @@ const usedBytes = 2;
  */
 let SuperBlock = (() => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-    let _classDecorators = [struct(packed, { name: 'SuperBlock' })];
+    let _classDecorators = [struct.packed('Superblock')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BigUint64Array;
+    let _classSuper = $from.typed(BigUint64Array);
     let _checksum_decorators;
     let _checksum_initializers = [];
     let _checksum_extraInitializers = [];

package/dist/backends/store/fs.js

@@ -136,7 +136,9 @@ export class StoreFS extends FileSystem {
     async ready() {
         if (this._initialized)
             return;
-        this.checkRootSync();
+        if (!this.attributes.has('no_async_preload')) {
+            this.checkRootSync();
+        }
         await this.checkRoot();
         await this._populate();
         this._initialized = true;

package/dist/internal/inode.d.ts

@@ -6,14 +6,14 @@ import { type V_Context } from './contexts.js';
  * @hidden
  */
 export declare const rootIno = 0;
+declare const Attributes_base: import("memium").StructConstructor<BufferView<any>>;
 /**
  * Extended attributes
  * @category Internals
  * @internal
  */
-export declare class Attributes extends BufferView {
+export declare class Attributes extends Attributes_base {
     accessor size: number;
-    ['constructor']: typeof Attributes;
     get byteSize(): number;
     has(name: string): boolean;
     get(name: string): Uint8Array | undefined;
@@ -100,12 +100,13 @@ export declare enum InodeFlags {
 export declare const userVisibleFlags = 253951;
 /** User modifiable flags */
 export declare const userModifiableFlags = 229631;
+declare const Inode_base: import("memium").StructConstructor<BufferView<any>>;
 /**
  * Generic inode definition that can easily be serialized.
  * @category Internals
  * @internal
  */
-export declare class Inode extends BufferView implements InodeLike {
+export declare class Inode extends Inode_base implements InodeLike {
     constructor(...args: ConstructorParameters<typeof BufferView> | [Readonly<Partial<InodeLike>>]);
     accessor data: number;
     /** For future use */
@@ -193,3 +194,4 @@ export declare function isFIFO(metadata: {
  * @internal
  */
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
+export {};

package/dist/internal/inode.js

@@ -34,7 +34,8 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { withErrno } from 'kerium';
 import { crit, warn } from 'kerium/log';
-import { field, packed, sizeof, struct, types as t } from 'memium';
+import { sizeof } from 'memium';
+import { $from, field, struct, types as t } from 'memium/decorators';
 import { decodeUTF8, encodeUTF8, pick } from 'utilium';
 import { BufferView } from 'utilium/buffer.js';
 import * as c from '../vfs/constants.js';
@@ -49,11 +50,11 @@ export const rootIno = 0;
 const maxDynamicData = 3968;
 let Attribute = (() => {
     var _a, _b;
-    let _classDecorators = [struct(packed, { name: 'Attribute' })];
+    let _classDecorators = [struct.packed('Attribute')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = Uint8Array;
+    let _classSuper = $from.typed(Uint8Array);
     let _keySize_decorators;
     let _keySize_initializers = [];
     let _keySize_extraInitializers = [];
@@ -120,11 +121,11 @@ let Attribute = (() => {
  */
 let Attributes = (() => {
     var _a;
-    let _classDecorators = [struct(packed, { name: 'Attributes' })];
+    let _classDecorators = [struct.packed('Attributes')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _size_decorators;
     let _size_initializers = [];
     let _size_extraInitializers = [];
@@ -328,11 +329,11 @@ export const userModifiableFlags = 0x000380ff;
  */
 let Inode = (() => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-    let _classDecorators = [struct(packed, { name: 'Inode' })];
+    let _classDecorators = [struct.packed('Inode')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _data_decorators;
     let _data_initializers = [];
     let _data_extraInitializers = [];

package/dist/vfs/acl.d.ts

@@ -17,12 +17,14 @@ export declare const enum Tag {
      */
     _None = 0
 }
-export declare class Entry extends BufferView {
+declare const Entry_base: import("memium").StructConstructor<BufferView<any>>;
+export declare class Entry extends Entry_base {
     accessor tag: Tag;
     accessor perm: number;
     accessor id: number;
 }
-export declare class ACL extends BufferView {
+declare const ACL_base: import("memium").StructConstructor<BufferView<any>>;
+export declare class ACL extends ACL_base {
     accessor version: number;
     entries: Entry[];
     constructor(...args: ConstructorParameters<typeof BufferView>);
@@ -40,3 +42,4 @@ export declare function setChecks(enabled: boolean): void;
  * @param access The requested access, combination of `W_OK`, `R_OK`, and `X_OK`
  */
 export declare function check($: V_Context, inode: InodeLike, access: number): boolean;
+export {};

package/dist/vfs/acl.js

@@ -40,7 +40,8 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 */
 import { withErrno } from 'kerium';
 import { err } from 'kerium/log';
-import { packed, sizeof, struct, types as t } from 'memium';
+import { packed, sizeof } from 'memium';
+import { $from, struct, types as t } from 'memium/decorators';
 import { BufferView } from 'utilium/buffer.js';
 import { defaultContext } from '../internal/contexts.js';
 import { Attributes } from '../internal/inode.js';
@@ -67,11 +68,11 @@ export var Tag;
 })(Tag || (Tag = {}));
 let Entry = (() => {
     var _a, _b, _c;
-    let _classDecorators = [struct(packed, { name: 'Entry' })];
+    let _classDecorators = [struct('ACL.Entry', packed)];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _tag_decorators;
     let _tag_initializers = [];
     let _tag_extraInitializers = [];
@@ -115,11 +116,11 @@ let Entry = (() => {
 export { Entry };
 let ACL = (() => {
     var _a;
-    let _classDecorators = [struct(packed, { name: 'ACL' })];
+    let _classDecorators = [struct.packed('ACL')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _version_decorators;
     let _version_initializers = [];
     let _version_extraInitializers = [];

package/dist/vfs/dir.d.ts

@@ -28,7 +28,8 @@ export declare function ifToDt(mode: number): DirType;
  * @see `DTTOIF` in `dirent.h`
  */
 export declare function dtToIf(dt: DirType): number;
-export declare class Dirent<Name extends string | Buffer = string, TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends BufferView<TArrayBuffer> implements _Dirent<Name> {
+declare const Dirent_base: import("memium").StructConstructor<BufferView<any>>;
+export declare class Dirent<Name extends string | Buffer = string, TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends Dirent_base<TArrayBuffer> implements _Dirent<Name> {
     protected accessor ino: number;
     /** Reserved for 64-bit inodes */
     private accessor _ino;
@@ -100,5 +101,7 @@ export declare class Dir implements _Dir, AsyncIterator<Dirent> {
      * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
      */
     [Symbol.asyncIterator](): this;
+    [Symbol.dispose](): void;
     [Symbol.asyncDispose](): Promise<void>;
 }
+export {};

package/dist/vfs/dir.js

@@ -34,8 +34,9 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { Buffer } from 'buffer';
 import { withErrno } from 'kerium';
-import { packed, sizeof, struct, types as t } from 'memium';
 import { warn } from 'kerium/log';
+import { packed, sizeof } from 'memium';
+import { $from, struct, types as t } from 'memium/decorators';
 import { encodeUTF8 } from 'utilium';
 import { BufferView } from 'utilium/buffer.js';
 import { basename, dirname } from '../path.js';
@@ -72,11 +73,11 @@ export function dtToIf(dt) {
 }
 let Dirent = (() => {
     var _a, _b, _c;
-    let _classDecorators = [struct(packed, { name: 'Dirent' })];
+    let _classDecorators = [struct.packed('Dirent')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _ino_decorators;
     let _ino_initializers = [];
     let _ino_extraInitializers = [];
@@ -250,7 +251,10 @@ export class Dir {
     [Symbol.asyncIterator]() {
         return this;
     }
-    [Symbol.asyncDispose]() {
-        return Promise.resolve();
+    [Symbol.dispose]() {
+        this.closeSync();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
     }
 }

package/dist/vfs/ioctl.d.ts

@@ -1,7 +1,8 @@
 import { BufferView } from 'utilium/buffer.js';
 import type { V_Context } from '../context.js';
 import { Inode } from '../internal/inode.js';
-declare class fsxattr extends BufferView {
+declare const fsxattr_base: import("memium").StructConstructor<BufferView<any>>;
+declare class fsxattr extends fsxattr_base {
     /** xflags field value */
     accessor xflags: number;
     /** extsize field value */

package/dist/vfs/ioctl.js

@@ -39,7 +39,8 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { Errno, Exception, setUVMessage, UV } from 'kerium';
-import { sizeof, struct, types as t } from 'memium';
+import { sizeof } from 'memium';
+import { $from, struct, types as t } from 'memium/decorators';
 import { _throw } from 'utilium';
 import { BufferView } from 'utilium/buffer.js';
 import { Inode, InodeFlags } from '../internal/inode.js';
@@ -87,11 +88,11 @@ var XFlag;
 })(XFlag || (XFlag = {}));
 let fsxattr = (() => {
     var _a, _b, _c, _d, _e;
-    let _classDecorators = [struct({ name: 'fsxattr' })];
+    let _classDecorators = [struct('fsxattr')];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = BufferView;
+    let _classSuper = $from(BufferView);
     let _xflags_decorators;
     let _xflags_initializers = [];
     let _xflags_extraInitializers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.3.5",
+	"version": "2.3.7",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -67,11 +67,11 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^24.0.13",
+		"@types/node": "^24.1.0",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.3.4",
-		"memium": "^0.2.3",
+		"memium": "^0.3.7",
 		"readable-stream": "^4.5.2",
 		"utilium": "^2.3.3"
 	},

package/tests/common/inode.test.ts

@@ -0,0 +1,19 @@
+import { suite, test } from 'node:test';
+import { Inode } from '../../dist/internal/inode.js';
+import assert from 'node:assert';
+
+suite('Inode manipulation', () => {
+	const inode = new Inode();
+	inode.mode = 0o40755;
+	assert.equal(inode.mode, 0o40755);
+
+	test('Copy to new Inode using constructor and spread', () => {
+		const newInode = new Inode({ ...inode });
+		assert.equal(newInode.mode, inode.mode);
+	});
+
+	test('Copy to new Inode using Object.assign', () => {
+		const newInode = Object.assign(new Inode(), inode);
+		assert.equal(newInode.mode, inode.mode);
+	});
+});