adaptive-extender 0.10.5 → 0.11.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.11.0 (21.06.2026)
+- Added `Array.Of(type)` portable adapter for typed arrays, alongside the existing `Array.import`/`Array.export`.
+- Added `Set.Of(type)` portable adapter for typed sets.
+- Added `Map.AsRecord(type)` and `Map.AsTuples(typeKey, typeValue)` portable adapters (moved from a separate module into [map](./src/core/map.ts)).
+- Added `Date.AsTimestamp` and `Date.AsUnixSeconds` portable adapters converting `Date` to millisecond and Unix-second numbers respectively.
+- Added `Number.prototype.snap(step)` — snaps a number to the nearest multiple of the given step.
+- **Breaking:** Removed `Reflect.mapNull`, `Reflect.mapUndefined`, and `Reflect.mapNullable`. Use `Nullable.map`, `Optional.map` from the portable module instead.
+- **Breaking:** Renamed `Archive`/`ArchiveManager`/`ArchiveRepository` to `Cell`/`PortableCell`/`BufferedCell`. Construction is now done via `Storage` factory methods (`localStorage.openCell`, `localStorage.openPortableCell`, `localStorage.openBufferedCell`) — the storage backend is no longer hardcoded to `localStorage`.
+- **Breaking:** `@Field` decorator no longer accepts a positional string as the second argument. Use `{ name: "..." }` options object: `@Field(String, { name: "fieldName" })`.
+- `PortableCell.save()` returns `Promise<boolean>` — resolves `true` when persisted, `false` if cancelled (superseded or aborted); rejects only on serialization failure.
+- Internal: `portable.ts` de-anemia refactor — `FieldDescriptor`, `DescendantDescriptor`, and `ModelSchema` are now rich objects with their own behavior (`importInto`, `exportFrom`, `accepts`, `owns`); `SchemaResolver` absorbed into `ModelSchema.resolve()`; `Model.import`/`Model.export` are thin facades.
+
 ## 0.10.5 (13.06.2026)
 - Bugfix at [portable](./src/core/portable.ts).
 
@@ -16,7 +28,7 @@
 ## 0.9.13 (06.04.2026)
 - Added `Version` class for semantic versioning with `parse()`, `tryParse()` support.
 - Added `BigInt` portable support via `BigInt.import()` and `BigInt.export()`.
-- `ArchiveRepository.save()` is now `async` and returns `Promise<void>`. The promise resolves when the save completes and rejects on failure. A pending save is cancelled (with an `AbortError`) when superseded by a new call.
+- `ArchiveRepository.save()` is now `async` and returns `Promise<boolean>`. The promise resolves `true` when the save completes, `false` if cancelled (superseded by a subsequent call or aborted via `abort()`), and rejects only on serialization failure.
 - `Promise.withSignal` now has a default type parameter `T = void`.
 - Renamed `EnumFrom` adapter to `EnumAs`.
 

package/README.md

@@ -412,10 +412,10 @@ const repository = new ArchiveRepository("settings", Settings, new Settings());
 const settings = repository.content;
 settings.volume = 0.5;
 
-// save() is async — resolves when the write completes, rejects on failure
-await repository.save(); // save immediately
+// save() resolves true when persisted, false if cancelled (superseded or aborted), rejects only on serialization failure
+const saved = await repository.save(); // save immediately
 await repository.save(3000); // debounced — save after 3 seconds
-// A pending save is cancelled (AbortError) when superseded by a new call
+// A pending save resolves false when superseded by a new call or cancelled by abort()
 repository.reset(); // abort pending save and revert to initial state
 ```
 

package/dist/core/array.js

@@ -1,6 +1,7 @@
 "use strict";
 import "./global.js";
 import {} from "./promise.js";
+import {} from "./portable.js";
 const { trunc } = Math;
 Array.import = function (source, name) {
     if (!Array.isArray(source))
@@ -10,6 +11,22 @@ Array.import = function (source, name) {
 Array.export = function (source) {
     return source;
 };
+Array.Of = function (type) {
+    return {
+        [Symbol.hasInstance](instance) {
+            return Array[Symbol.hasInstance](instance);
+        },
+        get name() {
+            return `${type.name}[]`;
+        },
+        import(source, name) {
+            return Array.import(source, name).map((item, index) => type.import(item, `${name}[${index}]`));
+        },
+        export(source) {
+            return source.map(item => type.export(item));
+        },
+    };
+};
 Array.range = function (min, max) {
     min = trunc(min);
     max = trunc(max);

package/dist/core/date.js

@@ -1,5 +1,6 @@
 "use strict";
 import "./global.js";
+import {} from "./portable.js";
 Date.import = function (source, name) {
     if (typeof (source) !== "string")
         throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
@@ -13,6 +14,38 @@ Date.isInvalid = function (date) {
         return false;
     return Number.isNaN(date.getTime());
 };
+Date.AsTimestamp = {
+    [Symbol.hasInstance](instance) {
+        return Date[Symbol.hasInstance](instance);
+    },
+    get name() {
+        return "Timestamp";
+    },
+    import(source, name) {
+        if (typeof (source) !== "number")
+            throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
+        return new Date(source);
+    },
+    export(source) {
+        return source.getTime();
+    },
+};
+Date.AsUnixSeconds = {
+    [Symbol.hasInstance](instance) {
+        return Date[Symbol.hasInstance](instance);
+    },
+    get name() {
+        return "UnixSeconds";
+    },
+    import(source, name) {
+        if (typeof (source) !== "number")
+            throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
+        return new Date(source * 1000);
+    },
+    export(source) {
+        return Math.trunc(source.getTime() / 1000);
+    },
+};
 Date.prototype.insteadInvalid = function (value) {
     if (Date.isInvalid(this))
         return value;

package/dist/core/global.js

@@ -1,5 +1,4 @@
 "use strict";
-Reflect.set(Symbol, "metadata", Reflect.get(Symbol, "metadata") ?? Symbol.for("Symbol.metadata"));
 globalThis.constructor = function (value) {
     return value.constructor;
 };

package/dist/core/map.js

@@ -1,8 +1,54 @@
 "use strict";
+import {} from "./portable.js";
+Map.AsRecord = function (type) {
+    return {
+        [Symbol.hasInstance](instance) {
+            return Map[Symbol.hasInstance](instance);
+        },
+        get name() {
+            return `Map<string, ${type.name}>`;
+        },
+        import(source, name) {
+            const record = Object.import(source, name);
+            const map = new Map();
+            for (const key of Object.keys(record)) {
+                map.set(key, type.import(Reflect.get(record, key), `${name}[${JSON.stringify(key)}]`));
+            }
+            return map;
+        },
+        export(source) {
+            const record = {};
+            for (const [key, value] of source) {
+                Reflect.set(record, key, type.export(value));
+            }
+            return record;
+        },
+    };
+};
+Map.AsTuples = function (typeKey, typeValue) {
+    return {
+        [Symbol.hasInstance](instance) {
+            return Map[Symbol.hasInstance](instance);
+        },
+        get name() {
+            return `Map<${typeKey.name}, ${typeValue.name}>`;
+        },
+        import(source, name) {
+            return new Map(Array.import(source, name).map((item, index) => {
+                const tuple = Array.import(item, `${name}[${index}]`);
+                const key = typeKey.import(tuple[0], `${name}[${index}][0]`);
+                const value = typeValue.import(tuple[1], `${name}[${index}][1]`);
+                return [key, value];
+            }));
+        },
+        export(source) {
+            return Array.from(source, ([key, value]) => [typeKey.export(key), typeValue.export(value)]);
+        },
+    };
+};
 Map.prototype.add = function (key, value) {
     if (this.has(key))
         return false;
     this.set(key, value);
     return true;
 };
-export {};

package/dist/core/math.js

@@ -1,5 +1,5 @@
 "use strict";
-const { PI, trunc, pow } = Math;
+const { PI, trunc, pow, round } = Math;
 Number.prototype.clamp = function (min, max) {
     let result = this.valueOf();
     if (result < min)
@@ -8,6 +8,11 @@ Number.prototype.clamp = function (min, max) {
         return max;
     return result;
 };
+function normalize(value, min, max) {
+    if (min === max)
+        throw new Error("Minimum and maximum of the original range cant be equal");
+    return (value - min) / (max - min);
+}
 function lerp(value, min1, max1, min2, max2) {
     if (min1 === max1)
         throw new Error("Minimum and maximum of the original range cant be equal");
@@ -17,18 +22,24 @@ function lerp(value, min1, max1, min2, max2) {
 }
 Number.prototype.lerp = function (min1, max1, min2, max2) {
     if (min2 === undefined || max2 === undefined)
-        return lerp(this.valueOf(), min1, max1, 0, 1);
+        return normalize(this.valueOf(), min1, max1);
     return lerp(this.valueOf(), min1, max1, min2, max2);
 };
-function mod(value, start, length) {
+function repeat(value, length) {
     if (length === 0)
         throw new RangeError("Length must not be zero");
-    return ((value - start) % length + length) % length + start;
+    return (value % length + length) % length;
+}
+function wrap(value, start, length) {
+    return repeat(value - start, length) + start;
 }
 Number.prototype.mod = function (arg1, arg2) {
     if (arg2 === undefined)
-        return mod(this.valueOf(), 0, arg1);
-    return mod(this.valueOf(), arg1, arg2);
+        return repeat(this.valueOf(), arg1);
+    return wrap(this.valueOf(), arg1, arg2);
+};
+Number.prototype.snap = function (step) {
+    return round(this.valueOf() / step) * step;
 };
 Math.split = function (x) {
     const integer = trunc(x);

package/dist/core/portable.js

@@ -9,28 +9,35 @@ import "./reflect.js";
 import "./error.js";
 import {} from "./global.js";
 //#endregion
-//#region Field descriptor
+//#region Descriptors
+Reflect.set(Symbol, "metadata", Reflect.get(Symbol, "metadata") ?? Symbol.for("Symbol.metadata"));
 class FieldDescriptor {
     #key;
     #association;
     #type;
-    constructor(key, association, type) {
+    #hasFallback = false;
+    #fallback;
+    constructor(key, type, options = {}) {
         this.#key = key;
-        this.#association = association;
+        this.#association = options.name ?? key;
         this.#type = type;
+        if (!("fallback" in options))
+            return;
+        this.#hasFallback = true;
+        this.#fallback = type.export(options.fallback);
     }
-    get key() {
-        return this.#key;
+    get key() { return this.#key; }
+    get association() { return this.#association; }
+    import(object, name) {
+        const association = this.#association;
+        const raw = Reflect.get(object, association);
+        const source = raw === undefined && this.#hasFallback ? this.#fallback : raw;
+        return this.#type.import(source, `${name}.${association}`);
     }
-    get association() {
-        return this.#association;
-    }
-    get type() {
-        return this.#type;
+    export(source) {
+        return this.#type.export(Reflect.get(source, this.#key));
     }
 }
-//#endregion
-//#region Descendant descriptor
 class DescendantDescriptor {
     #type;
     #discriminator;
@@ -38,15 +45,99 @@ class DescendantDescriptor {
         this.#type = type;
         this.#discriminator = discriminator;
     }
-    get type() {
-        return this.#type;
+    get discriminator() { return this.#discriminator ?? this.#type.name; }
+    accepts(discriminator) {
+        return this.discriminator === discriminator;
+    }
+    owns(instance) {
+        return instance instanceof this.#type;
     }
-    get discriminator() {
-        return this.#discriminator ?? this.#type.name;
+    import(source, name) {
+        return this.#type.import(source, name);
+    }
+    export(source) {
+        return this.#type.export(source);
+    }
+}
+class ModelSchema {
+    static #schemas = new WeakMap();
+    static #collect(object) {
+        const fields = new Map();
+        let current = object;
+        while (current !== null) {
+            for (const [key, descriptor] of PortabilityMetadata.for(current).fields)
+                fields.add(key, descriptor);
+            current = Object.getPrototypeOf(current);
+        }
+        return fields;
+    }
+    static resolve(model) {
+        const schemas = ModelSchema.#schemas;
+        let schema = schemas.get(model);
+        if (schema !== undefined)
+            return schema;
+        const object = ReferenceError.suppress(model[Symbol.metadata], `Required an implementation of Symbol.metadata in '${model.name}' to use portability`);
+        const { discriminator, descendants } = Object.hasOwn(model, Symbol.metadata)
+            ? PortabilityMetadata.for(object)
+            : new PortabilityMetadata();
+        schema = descendants.length > 0
+            ? new PolymorphicSchema(discriminator, descendants)
+            : new ConcreteSchema(model, ModelSchema.#collect(object));
+        schemas.set(model, schema);
+        return schema;
+    }
+}
+class ConcreteSchema extends ModelSchema {
+    #model;
+    #fields;
+    constructor(model, fields) {
+        super();
+        this.#model = model;
+        this.#fields = fields;
+    }
+    import(source, name) {
+        const object = Object.import(source, name);
+        const instance = Reflect.construct(this.#model, []);
+        for (const descriptor of this.#fields.values())
+            Reflect.set(instance, descriptor.key, descriptor.import(object, name));
+        return instance;
+    }
+    export(source) {
+        const target = new Object();
+        for (const descriptor of this.#fields.values())
+            Reflect.set(target, descriptor.association, descriptor.export(source));
+        return target;
+    }
+}
+class PolymorphicSchema extends ModelSchema {
+    #discriminator;
+    #descendants;
+    constructor(discriminator, descendants) {
+        super();
+        this.#discriminator = discriminator;
+        this.#descendants = descendants;
+    }
+    import(source, name) {
+        const key = this.#discriminator;
+        const object = Object.import(source, name);
+        const value = Reflect.get(object, key);
+        if (value === undefined)
+            throw new TypeError(`Missing '${key}' discriminator in ${name}`);
+        const discriminator = String.import(value, `${name}.${key}`);
+        const descriptor = this.#descendants.find(descendant => descendant.accepts(discriminator));
+        if (descriptor === undefined)
+            throw new TypeError(`Unknown '${discriminator}' discriminator for ${name}`);
+        return descriptor.import(source, name);
+    }
+    export(source) {
+        const descriptor = this.#descendants.find(descendant => descendant.owns(source));
+        if (descriptor === undefined)
+            throw new TypeError(`Invalid '${typename(source)}' type for source`);
+        const exported = descriptor.export(source);
+        Reflect.set(exported, this.#discriminator, descriptor.discriminator);
+        return exported;
     }
 }
-//#endregion
-//#region Portability metadata
 class PortabilityMetadata {
     static #registry = new WeakMap();
     #fields = new Map();
@@ -61,40 +152,10 @@ class PortabilityMetadata {
         registry.set(metadata, entry);
         return entry;
     }
-    static read(model) {
-        const object = ReferenceError.suppress(model[Symbol.metadata], `Required an implementation of Symbol.metadata in '${model.name}' to use portability`);
-        const metadata = PortabilityMetadata.for(object);
-        const fields = metadata.#fields;
-        let current = object;
-        while (true) {
-            if (current === null)
-                break;
-            for (const [key, descriptor] of PortabilityMetadata.for(current).#fields)
-                fields.add(key, descriptor);
-            current = Object.getPrototypeOf(current);
-        }
-        return metadata;
-    }
-    static descendantsOf(model) {
-        if (!Object.hasOwn(model, Symbol.metadata))
-            return [];
-        const object = model[Symbol.metadata];
-        if (object === null || object === undefined)
-            return [];
-        return PortabilityMetadata.for(object).#descendants;
-    }
-    get fields() {
-        return this.#fields;
-    }
-    get descendants() {
-        return this.#descendants;
-    }
-    get discriminator() {
-        return this.#discriminator;
-    }
-    set discriminator(value) {
-        this.#discriminator = value;
-    }
+    get fields() { return this.#fields; }
+    get descendants() { return this.#descendants; }
+    get discriminator() { return this.#discriminator; }
+    set discriminator(value) { this.#discriminator = value; }
 }
 //#endregion
 //#region Model
@@ -110,89 +171,28 @@ export class Model {
      * @throws {TypeError} If validation fails or types do not match.
      */
     static import(source, name) {
-        const model = this;
-        const descendants = PortabilityMetadata.descendantsOf(model);
-        if (descendants.length > 0) {
-            const { discriminator: key } = PortabilityMetadata.read(model);
-            const object = Object.import(source, name);
-            const value = Reflect.get(object, key);
-            if (value === undefined)
-                throw new TypeError(`Missing '${key}' discriminator in ${name}`);
-            const discriminator = String.import(value, `${name}.${key}`);
-            const descriptor = descendants.find(descriptor => descriptor.discriminator === discriminator);
-            if (descriptor === undefined)
-                throw new TypeError(`Unknown '${discriminator}' discriminator for ${name}`);
-            return descriptor.type.import(source, name);
-        }
-        const object = Object.import(source, name);
-        const instance = Reflect.construct(this, []);
-        const { fields } = PortabilityMetadata.read(model);
-        for (const { key, association, type } of fields.values()) {
-            const raw = Reflect.get(object, association);
-            const value = type.import(raw, `${name}.${association}`);
-            Reflect.set(instance, key, value);
-        }
-        return instance;
+        return ModelSchema.resolve(this).import(source, name);
     }
     /**
      * Serializes the model instance to a raw object.
      * @param source The model instance to export.
      */
     static export(source) {
-        const model = this;
-        const descendants = PortabilityMetadata.descendantsOf(model);
-        if (descendants.length > 0) {
-            const { discriminator: key } = PortabilityMetadata.read(model);
-            const descriptor = descendants.find(descriptor => source instanceof descriptor.type);
-            if (descriptor === undefined)
-                throw new TypeError(`Invalid '${typename(source)}' type for source`);
-            const descendant = descriptor.type;
-            const exported = descendant.export(source);
-            Reflect.set(exported, key, descriptor.discriminator);
-            return exported;
-        }
-        const object = new Object();
-        const { fields } = PortabilityMetadata.read(model);
-        for (const { key, association, type } of fields.values()) {
-            const value = Reflect.get(source, key);
-            const raw = type.export(value);
-            Reflect.set(object, association, raw);
-        }
-        return object;
+        return ModelSchema.resolve(this).export(source);
     }
 }
-export function Field(type, name) {
+export function Field(type, options = {}) {
     return function (_, context) {
         if (context.static)
             throw new TypeError("Portable fields cannot be static");
         const key = context.name;
         if (typeof (key) === "symbol")
             throw new TypeError("Symbols are not supported as portable keys");
-        const association = name ?? key;
         const { fields } = PortabilityMetadata.for(context.metadata);
         if (!fields.has(key))
-            fields.set(key, new FieldDescriptor(key, association, type));
-    };
-}
-export function Descendant(descendant, discriminator) {
-    return function (model, context) {
-        void model;
-        const { descendants } = PortabilityMetadata.for(context.metadata);
-        descendants.push(new DescendantDescriptor(descendant, discriminator));
-    };
-}
-/**
- * Decorator to register a custom discriminator key for the polymorphic model.
- * @param key The property key to use for the discriminator.
- */
-export function DiscriminatorKey(key) {
-    return function (model, context) {
-        void model;
-        PortabilityMetadata.for(context.metadata).discriminator = key;
+            fields.set(key, new FieldDescriptor(key, type, options));
     };
 }
-//#endregion
-//#region Adapters
 /**
  * Creates a wrapper for circular or deferred type references.
  * @param resolver Function that returns the actual type constructor.
@@ -213,224 +213,158 @@ export function Deferred(resolver) {
         },
     };
 }
-/**
- * Creates a portable wrapper for optional types.
- * @param type The inner portable type.
- */
-export function Optional(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return instance === undefined || type[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `${type.name} | undefined`;
-        },
-        import(source, name) {
-            return Reflect.mapUndefined(source, source => type.import(source, name));
-        },
-        export(source) {
-            return Reflect.mapUndefined(source, source => type.export(source));
-        },
-    };
-}
-/**
- * Creates a portable wrapper for nullable types.
- * @param type The inner portable type.
- */
-export function Nullable(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return instance === null || type[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `${type.name} | null`;
-        },
-        import(source, name) {
-            return Reflect.mapNull(source, source => type.import(source, name));
-        },
-        export(source) {
-            return Reflect.mapNull(source, source => type.export(source));
-        },
-    };
-}
-/**
- * Creates a portable wrapper for array types.
- * @param type The portable type of the array elements.
- */
-export function ArrayOf(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Array[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `${type.name}[]`;
-        },
-        import(source, name) {
-            return Array.import(source, name).map((item, index) => type.import(item, `${name}[${index}]`));
-        },
-        export(source) {
-            return source.map(item => type.export(item));
-        },
+export function Descendant(descendant, discriminator) {
+    return function (model, context) {
+        void model;
+        const { descendants } = PortabilityMetadata.for(context.metadata);
+        descendants.push(new DescendantDescriptor(descendant, discriminator));
     };
 }
 /**
- * Creates a portable wrapper for set types.
- * @param type The portable type of the set elements.
+ * Decorator to register a custom discriminator key for the polymorphic model.
+ * @param key The property key to use for the discriminator.
  */
-export function SetOf(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Set[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `Set<${type.name}>`;
-        },
-        import(source, name) {
-            return new Set(Array.import(source, name).map((item, index) => type.import(item, `${name}[${index}]`)));
-        },
-        export(source) {
-            return Array.from(source, item => type.export(item));
-        },
+export function DiscriminatorKey(key) {
+    return function (model, context) {
+        void model;
+        PortabilityMetadata.for(context.metadata).discriminator = key;
     };
 }
+//#endregion
+//#region Adapters
 /**
- * Creates a portable wrapper for maps with string keys, converting them to and from plain objects.
- * @param value The portable type of the map values.
+ * Portable adapter class for optional (possibly-undefined) types.
+ * Use `Optional.Of(type)` to wrap an adapter, and `Optional.map` for conditional mapping.
  */
-export function RecordOf(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Map[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `Map<string, ${type.name}>`;
-        },
-        import(source, name) {
-            const record = Object.import(source, name);
-            const map = new Map();
-            for (const key of Object.keys(record)) {
-                map.set(key, type.import(Reflect.get(record, key), `${name}[${JSON.stringify(key)}]`));
-            }
-            return map;
-        },
-        export(source) {
-            const record = {};
-            for (const [key, value] of source) {
-                Reflect.set(record, key, type.export(value));
-            }
-            return record;
-        },
-    };
+export class Optional {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    /**
+     * Creates a portable wrapper for optional types.
+     * @param type The inner portable type.
+     */
+    static Of(type) {
+        return {
+            [Symbol.hasInstance](instance) {
+                return type[Symbol.hasInstance](instance);
+            },
+            get name() {
+                return `${type.name} | undefined`;
+            },
+            import(source, name) {
+                return Optional.map(source, source => type.import(source, name));
+            },
+            export(source) {
+                return Optional.map(source, source => type.export(source));
+            },
+        };
+    }
+    /**
+     * Applies a callback to a non-undefined value, or passes through `undefined` unchanged.
+     * @param value The value to map.
+     * @param callback The function to apply if the value is not undefined.
+     */
+    static map(value, callback) {
+        if (value === undefined)
+            return value;
+        return callback(value);
+    }
 }
 /**
- * Creates a portable wrapper for maps with arbitrary key and value types, converting them to and from arrays of `[key, value]` tuples.
- * @param key The portable type of the map keys.
- * @param value The portable type of the map values.
+ * Portable adapter class for nullable (possibly-null) types.
+ * Use `Nullable.Of(type)` to wrap an adapter, and `Nullable.map` for conditional mapping.
  */
-export function MapOf(typeKey, typeValue) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Map[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `Map<${typeKey.name}, ${typeValue.name}>`;
-        },
-        import(source, name) {
-            return new Map(Array.import(source, name).map((item, index) => {
-                const tuple = Array.import(item, `${name}[${index}]`);
-                const key = typeKey.import(tuple[0], `${name}[${index}][0]`);
-                const value = typeValue.import(tuple[1], `${name}[${index}][1]`);
-                return [key, value];
-            }));
-        },
-        export(source) {
-            return Array.from(source, ([key, value]) => [typeKey.export(key), typeValue.export(value)]);
-        },
-    };
+export class Nullable {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    /**
+     * Creates a portable wrapper for nullable types.
+     * @param type The inner portable type.
+     */
+    static Of(type) {
+        return {
+            [Symbol.hasInstance](instance) {
+                return type[Symbol.hasInstance](instance);
+            },
+            get name() {
+                return `${type.name} | null`;
+            },
+            import(source, name) {
+                return Nullable.map(source, source => type.import(source, name));
+            },
+            export(source) {
+                return Nullable.map(source, source => type.export(source));
+            },
+        };
+    }
+    /**
+     * Applies a callback to a non-null value, or passes through `null` unchanged.
+     * @param value The value to map.
+     * @param callback The function to apply if the value is not null.
+     */
+    static map(value, callback) {
+        if (value === null)
+            return value;
+        return callback(value);
+    }
 }
 /**
- * Creates a portable wrapper for enum types, strictly operating only on enum values.
- * @param reference The enum object reference.
+ * Portable adapter class for enum types.
+ * Use `Enum.Of(reference)` to create an adapter that validates against enum values.
  */
-export function EnumAs(reference) {
-    const values = new Set();
-    for (const [key, value] of Object.entries(reference)) {
-        const index = Number(key);
-        if (String(index) === key && typeof value === "string" && Reflect.get(reference, value) === index)
-            continue;
-        values.add(value);
+export class Enum {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    /**
+     * Creates a portable wrapper for enum types, strictly operating only on enum values.
+     * @param reference The enum object reference.
+     */
+    static Of(reference) {
+        const values = new Set();
+        for (const [key, value] of Object.entries(reference)) {
+            const index = Number(key);
+            if (String(index) === key && typeof value === "string" && Reflect.get(reference, value) === index)
+                continue;
+            values.add(value);
+        }
+        return {
+            [Symbol.hasInstance](instance) {
+                return values.has(instance);
+            },
+            get name() {
+                return "Enum";
+            },
+            import(source, name) {
+                if (!values.has(source))
+                    throw new TypeError(`Unable to import enum from ${name} due to invalid value`);
+                return source;
+            },
+            export(source) {
+                return source;
+            },
+        };
     }
-    return {
-        [Symbol.hasInstance](instance) {
-            return values.has(instance);
-        },
-        get name() {
-            return "Enum";
-        },
-        import(source, name) {
-            if (!values.has(source))
-                throw new TypeError(`Unable to import enum from ${name} due to invalid value`);
-            return source;
-        },
-        export(source) {
-            return source;
-        },
-    };
 }
 /**
- * A portable adapter that facilitates the conversion between `Date` instances and millisecond timestamps.
- */
-export const Timestamp = {
-    [Symbol.hasInstance](instance) {
-        return Date[Symbol.hasInstance](instance);
-    },
-    get name() {
-        return "Timestamp";
-    },
-    import(source, name) {
-        if (typeof (source) !== "number")
-            throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
-        return new Date(source);
-    },
-    export(source) {
-        return source.getTime();
-    },
-};
-/**
- * A portable adapter that facilitates the conversion between `Date` instances and Unix second timestamps.
- */
-export const UnixSeconds = {
-    [Symbol.hasInstance](instance) {
-        return Date[Symbol.hasInstance](instance);
-    },
-    get name() {
-        return "UnixSeconds";
-    },
-    import(source, name) {
-        if (typeof (source) !== "number")
-            throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
-        return new Date(source * 1000);
-    },
-    export(source) {
-        return Math.trunc(source.getTime() / 1000);
-    },
-};
-/**
- * A portable adapter that allows any value to pass through without validation or transformation.
+ * Portable adapter class for unknown/any types.
+ * Pass `Any` directly to `@Field` to allow any value without validation or transformation.
  */
-export const Any = {
-    [Symbol.hasInstance](instance) {
+export class Any {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    static [Symbol.hasInstance](instance) {
         void instance;
         return true;
-    },
-    get name() {
-        return "Any";
-    },
-    import(source, name) {
+    }
+    static import(source, name) {
         void name;
         return source;
-    },
-    export(source) {
+    }
+    static export(source) {
         return source;
-    },
-};
+    }
+}

package/dist/core/reflect.js

@@ -1,17 +1,2 @@
 "use strict";
-Reflect.mapNull = function (value, callback) {
-    if (value === null)
-        return value;
-    return callback(value);
-};
-Reflect.mapUndefined = function (value, callback) {
-    if (value === undefined)
-        return value;
-    return callback(value);
-};
-Reflect.mapNullable = function (value, callback) {
-    if (value === null || value === undefined)
-        return value;
-    return callback(value);
-};
 export {};

package/dist/core/set.js

@@ -1,4 +1,21 @@
 "use strict";
+import {} from "./portable.js";
+Set.Of = function (type) {
+    return {
+        [Symbol.hasInstance](instance) {
+            return Set[Symbol.hasInstance](instance);
+        },
+        get name() {
+            return `Set<${type.name}>`;
+        },
+        import(source, name) {
+            return new Set(Array.import(source, name).map((item, index) => type.import(item, `${name}[${index}]`)));
+        },
+        export(source) {
+            return Array.from(source, item => type.export(item));
+        },
+    };
+};
 Set.prototype.toggle = function (value, force) {
     if (force === undefined) {
         if (this.has(value)) {
@@ -15,4 +32,3 @@ Set.prototype.toggle = function (value, force) {
     this.delete(value);
     return false;
 };
-export {};

package/dist/web/archive.js

@@ -1,23 +1,26 @@
 "use strict";
 import "../core/index.js";
 import {} from "../core/index.js";
-//#region Archive
+//#region Cell
 /**
- * Low-level interface for persistent data storage.
- * Handles direct serialization and retrieval from the platform's local storage.
+ * Low-level interface for a single keyed entry in a {@link Storage} backend.
+ * Handles direct serialization and retrieval of raw data.
  */
-class Archive {
+export class Cell {
+    #storage;
     #key;
     /**
+     * @param storage The underlying storage backend.
      * @param key Unique storage identifier.
-     * @param initial Default value used if no data exists at the specified key.
+     * @param initial Default value written if no data exists at the specified key.
      */
-    constructor(key, initial) {
+    constructor(storage, key, initial) {
+        this.#storage = storage;
         this.#key = key;
         this.#initialize(initial);
     }
     #initialize(value) {
-        if (localStorage.getItem(this.#key) !== null)
+        if (this.#storage.getItem(this.#key) !== null)
             return;
         this.data = value;
     }
@@ -26,7 +29,7 @@ class Archive {
             return JSON.stringify(value);
         }
         catch {
-            throw new SyntaxError(`Archive [${key}]: Serialization failed.`);
+            throw new SyntaxError(`Cell [${key}]: Serialization failed.`);
         }
     }
     static #decompress(key, text) {
@@ -34,7 +37,7 @@ class Archive {
             return JSON.parse(text);
         }
         catch {
-            throw new SyntaxError(`Archive [${key}]: Data corrupted.`);
+            throw new SyntaxError(`Cell [${key}]: Data corrupted.`);
         }
     }
     /**
@@ -49,10 +52,10 @@ class Archive {
      * @throws {SyntaxError} If the data is corrupted and cannot be parsed.
      */
     get data() {
-        const text = localStorage.getItem(this.#key);
+        const text = this.#storage.getItem(this.#key);
         if (text === null)
-            throw new ReferenceError(`Archive [${this.#key}]: Entry not found.`);
-        return Archive.#decompress(this.#key, text);
+            throw new ReferenceError(`Cell [${this.#key}]: Entry not found.`);
+        return Cell.#decompress(this.#key, text);
     }
     /**
      * Overwrites the raw data in the underlying storage.
@@ -60,28 +63,29 @@ class Archive {
      * @throws {SyntaxError} If the value cannot be serialized.
      */
     set data(value) {
-        const text = Archive.#compress(this.#key, value);
-        localStorage.setItem(this.#key, text);
+        const text = Cell.#compress(this.#key, value);
+        this.#storage.setItem(this.#key, text);
     }
 }
 //#endregion
-//#region Archive manager
+//#region Portable cell
 /**
  * Orchestrates the lifecycle and state-to-model mapping for a specific data type.
  */
-export class ArchiveManager {
-    #archive;
+export class PortableCell {
+    #cell;
     #model;
     #initial;
     /**
+     * @param storage The underlying storage backend.
      * @param key Unique storage identifier.
      * @param model Constructor with import/export capabilities.
      * @param instance Baseline object state for initialization and resets.
      * @throws {TypeError} If the provided instance is incompatible with the model schema.
      */
-    constructor(key, model, instance) {
-        const scheme = ArchiveManager.#ensureCompatibility(key, model, instance);
-        this.#archive = new Archive(key, scheme);
+    constructor(storage, key, model, instance) {
+        const scheme = PortableCell.#ensureCompatibility(key, model, instance);
+        this.#cell = new Cell(storage, key, scheme);
         this.#model = model;
         this.#initial = scheme;
     }
@@ -95,14 +99,14 @@ export class ArchiveManager {
         }
         catch (reason) {
             const { message } = Error.from(reason);
-            throw new TypeError(`Archive [${key}]: Schema validation failed: ${message}`);
+            throw new TypeError(`PortableCell [${key}]: Schema validation failed: ${message}`);
         }
     }
     /**
      * The storage identifier managed by this instance.
      */
     get key() {
-        return this.#archive.key;
+        return this.#cell.key;
     }
     /**
      * Deserializes and reconstructs the model instance from the storage.
@@ -110,12 +114,12 @@ export class ArchiveManager {
      */
     get content() {
         try {
-            return this.#model.import(this.#archive.data, this.#archive.key);
+            return this.#model.import(this.#cell.data, this.#cell.key);
         }
         catch (error) {
             if (!(error instanceof TypeError))
                 throw error;
-            throw new SyntaxError(`Archive [${this.#archive.key}]: Content restoration failed.`);
+            throw new SyntaxError(`PortableCell [${this.#cell.key}]: Content restoration failed.`);
         }
     }
     /**
@@ -124,17 +128,17 @@ export class ArchiveManager {
      * @throws {SyntaxError} If the instance state cannot be serialized.
      */
     set content(value) {
-        this.#archive.data = this.#model.export(value);
+        this.#cell.data = this.#model.export(value);
     }
     /**
      * Reverts the storage to the original state provided at construction.
      */
     reset() {
-        this.#archive.data = this.#initial;
+        this.#cell.data = this.#initial;
     }
 }
 //#endregion
-//#region Archive repository
+//#region Buffered cell
 class SaveTransaction {
     #idTimeout;
     #resolve;
@@ -144,14 +148,14 @@ class SaveTransaction {
         this.#resolve = resolve;
         this.#reject = reject;
     }
-    cancel(reason) {
+    cancel() {
         clearTimeout(this.#idTimeout);
-        this.#reject(new DOMException(reason, "AbortError"));
+        this.#resolve(false);
     }
     settle(callback) {
         try {
-            const result = callback();
-            this.#resolve(result);
+            callback();
+            this.#resolve(true);
         }
         catch (reason) {
             this.#reject(Error.from(reason));
@@ -159,20 +163,21 @@ class SaveTransaction {
     }
 }
 /**
- * A high-level repository providing buffered access to persistent data with auto-save management.
+ * A high-level cell providing buffered access to persistent data with auto-save management.
  */
-export class ArchiveRepository {
-    #manager;
+export class BufferedCell {
+    #cell;
     #content;
     #transaction = null;
     /**
+     * @param storage The underlying storage backend.
      * @param key Unique storage identifier.
      * @param model Constructor for state transformation.
      * @param instance Initial state template.
      */
-    constructor(key, model, instance) {
-        this.#manager = new ArchiveManager(key, model, instance);
-        this.#content = this.#manager.content;
+    constructor(storage, key, model, instance) {
+        this.#cell = new PortableCell(storage, key, model, instance);
+        this.#content = this.#cell.content;
         this.#initializeUnloadHandler();
     }
     #initializeUnloadHandler() {
@@ -187,7 +192,7 @@ export class ArchiveRepository {
      * The unique storage identifier.
      */
     get key() {
-        return this.#manager.key;
+        return this.#cell.key;
     }
     /**
      * Retrieves the in-memory instance of the content.
@@ -200,22 +205,23 @@ export class ArchiveRepository {
         const transaction = this.#transaction;
         this.#transaction = null;
         transaction?.settle(() => {
-            this.#manager.content = this.#content;
+            this.#cell.content = this.#content;
         });
     }
     async save(delay) {
         const transaction = this.#transaction;
-        transaction?.cancel("Save superseded by a subsequent call.");
+        transaction?.cancel();
         return await new Promise((resolve, reject) => {
             this.#transaction = new SaveTransaction(this.#handler.bind(this), delay, resolve, reject);
         });
     }
     /**
      * Cancels any scheduled save operations.
+     * Any pending {@linkcode save} promise resolves to `false`.
      */
     abort() {
         const transaction = this.#transaction;
-        transaction?.cancel("Save operation explicitly aborted.");
+        transaction?.cancel();
         this.#transaction = null;
     }
     /**
@@ -223,8 +229,17 @@ export class ArchiveRepository {
      */
     reset() {
         this.abort();
-        const manager = this.#manager;
-        manager.reset();
-        this.#content = manager.content;
+        const cell = this.#cell;
+        cell.reset();
+        this.#content = cell.content;
     }
 }
+Storage.prototype.openCell = function (key, initial) {
+    return new Cell(this, key, initial);
+};
+Storage.prototype.openPortableCell = function (key, model, instance) {
+    return new PortableCell(this, key, model, instance);
+};
+Storage.prototype.openBufferedCell = function (key, model, instance) {
+    return new BufferedCell(this, key, model, instance);
+};

package/dist/web/metadata-injector.js

@@ -34,7 +34,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import "adaptive-extender/web";
-import { Model, Field, Optional, ArrayOf, DiscriminatorKey, Descendant, Deferred } from "adaptive-extender/web";
+import { Model, Field, Optional, DiscriminatorKey, Descendant, Deferred } from "adaptive-extender/web";
 //#region URL adapter
 const URLAdapter = {
     [Symbol.hasInstance](instance) {
@@ -80,12 +80,12 @@ let Metadata = (() => {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _context_decorators = [Field(String, "@context")];
-            _name_decorators = [Field(String, "name")];
-            _webpage_decorators = [Field(URLAdapter, "url")];
-            _preview_decorators = [Field(Optional(URLAdapter), "image")];
-            _description_decorators = [Field(Optional(String), "description")];
-            _keywords_decorators = [Field(Optional(ArrayOf(String)), "keywords")];
+            _context_decorators = [Field(String, { name: "@context" })];
+            _name_decorators = [Field(String, { name: "name" })];
+            _webpage_decorators = [Field(URLAdapter, { name: "url" })];
+            _preview_decorators = [Field(Optional.Of(URLAdapter), { name: "image" })];
+            _description_decorators = [Field(Optional.Of(String), { name: "description" })];
+            _keywords_decorators = [Field(Optional.Of(Array.Of(String)), { name: "keywords" })];
             __esDecorate(null, null, _context_decorators, { kind: "field", name: "context", static: false, private: false, access: { has: obj => "context" in obj, get: obj => obj.context, set: (obj, value) => { obj.context = value; } }, metadata: _metadata }, _context_initializers, _context_extraInitializers);
             __esDecorate(null, null, _name_decorators, { kind: "field", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
             __esDecorate(null, null, _webpage_decorators, { kind: "field", name: "webpage", static: false, private: false, access: { has: obj => "webpage" in obj, get: obj => obj.webpage, set: (obj, value) => { obj.webpage = value; } }, metadata: _metadata }, _webpage_initializers, _webpage_extraInitializers);
@@ -135,9 +135,9 @@ let PersonMetadata = (() => {
     return class PersonMetadata extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _associations_decorators = [Field(Optional(ArrayOf(URLAdapter)), "sameAs")];
-            _job_decorators = [Field(Optional(String), "jobTitle")];
-            _knowledge_decorators = [Field(Optional(ArrayOf(String)), "knowsAbout")];
+            _associations_decorators = [Field(Optional.Of(Array.Of(URLAdapter)), { name: "sameAs" })];
+            _job_decorators = [Field(Optional.Of(String), { name: "jobTitle" })];
+            _knowledge_decorators = [Field(Optional.Of(Array.Of(String)), { name: "knowsAbout" })];
             __esDecorate(null, null, _associations_decorators, { kind: "field", name: "associations", static: false, private: false, access: { has: obj => "associations" in obj, get: obj => obj.associations, set: (obj, value) => { obj.associations = value; } }, metadata: _metadata }, _associations_initializers, _associations_extraInitializers);
             __esDecorate(null, null, _job_decorators, { kind: "field", name: "job", static: false, private: false, access: { has: obj => "job" in obj, get: obj => obj.job, set: (obj, value) => { obj.job = value; } }, metadata: _metadata }, _job_initializers, _job_extraInitializers);
             __esDecorate(null, null, _knowledge_decorators, { kind: "field", name: "knowledge", static: false, private: false, access: { has: obj => "knowledge" in obj, get: obj => obj.knowledge, set: (obj, value) => { obj.knowledge = value; } }, metadata: _metadata }, _knowledge_initializers, _knowledge_extraInitializers);
@@ -173,9 +173,9 @@ let ApplicationMetadata = (() => {
     return class ApplicationMetadata extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _category_decorators = [Field(String, "applicationCategory")];
-            _os_decorators = [Field(String, "operatingSystem")];
-            _version_decorators = [Field(Optional(String), "softwareVersion")];
+            _category_decorators = [Field(String, { name: "applicationCategory" })];
+            _os_decorators = [Field(String, { name: "operatingSystem" })];
+            _version_decorators = [Field(Optional.Of(String), { name: "softwareVersion" })];
             __esDecorate(null, null, _category_decorators, { kind: "field", name: "category", static: false, private: false, access: { has: obj => "category" in obj, get: obj => obj.category, set: (obj, value) => { obj.category = value; } }, metadata: _metadata }, _category_initializers, _category_extraInitializers);
             __esDecorate(null, null, _os_decorators, { kind: "field", name: "os", static: false, private: false, access: { has: obj => "os" in obj, get: obj => obj.os, set: (obj, value) => { obj.os = value; } }, metadata: _metadata }, _os_initializers, _os_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);
@@ -211,9 +211,9 @@ let OrganizationMetadata = (() => {
     return class OrganizationMetadata extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _logo_decorators = [Field(Optional(URLAdapter), "logo")];
-            _email_decorators = [Field(Optional(String), "email")];
-            _foundation_decorators = [Field(Optional(Date), "foundingDate")];
+            _logo_decorators = [Field(Optional.Of(URLAdapter), { name: "logo" })];
+            _email_decorators = [Field(Optional.Of(String), { name: "email" })];
+            _foundation_decorators = [Field(Optional.Of(Date), { name: "foundingDate" })];
             __esDecorate(null, null, _logo_decorators, { kind: "field", name: "logo", static: false, private: false, access: { has: obj => "logo" in obj, get: obj => obj.logo, set: (obj, value) => { obj.logo = value; } }, metadata: _metadata }, _logo_initializers, _logo_extraInitializers);
             __esDecorate(null, null, _email_decorators, { kind: "field", name: "email", static: false, private: false, access: { has: obj => "email" in obj, get: obj => obj.email, set: (obj, value) => { obj.email = value; } }, metadata: _metadata }, _email_initializers, _email_extraInitializers);
             __esDecorate(null, null, _foundation_decorators, { kind: "field", name: "foundation", static: false, private: false, access: { has: obj => "foundation" in obj, get: obj => obj.foundation, set: (obj, value) => { obj.foundation = value; } }, metadata: _metadata }, _foundation_initializers, _foundation_extraInitializers);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "adaptive-extender",
-	"version": "0.10.5",
+	"version": "0.11.0",
 	"description": "Adaptive library for JS/TS development environments",
 	"type": "module",
 	"main": "./dist/core/index.js",
@@ -57,6 +57,7 @@
 		"build:web": "tsc -p ./src/web/tsconfig.json",
 		"build:worker": "tsc -p ./src/worker/tsconfig.json",
 		"build": "npm run build:core && npm run build:node && npm run build:web && npm run build:worker",
+		"prepublishOnly": "npm run build",
 		"test": "npm run build & vitest run",
 		"coverage": "vitest run --coverage"
 	},