edinburgh 0.1.3 → 0.4.1

package/build/src/types.js

@@ -1,483 +1,578 @@
-import { Bytes } from "./bytes.js";
-import * as olmdb from "olmdb";
-import { DatabaseError } from "olmdb";
-import { modelRegistry, getMockModel } from "./models.js";
-import { assert, addErrorPath } from "./utils.js";
+import DataPack from "./datapack.js";
+import { DatabaseError } from "olmdb/lowlevel";
+import { modelRegistry, currentTxn } from "./models.js";
+import { assert, addErrorPath, dbGet } from "./utils.js";
 /**
- * @internal Abstract base class for all type wrappers in the Edinburgh ORM system.
- *
- * This is an implementation detail and should not be referenced directly in user code.
- * Type wrappers define how values are serialized to/from the database and how they are validated.
- * Each type wrapper must implement serialization, deserialization, and validation logic.
- *
- * @template T - The TypeScript type this wrapper represents.
- */
+* @internal Abstract base class for all type wrappers in the Edinburgh ORM system.
+*
+* This is an implementation detail and should not be referenced directly in user code.
+* Type wrappers define how values are serialized to/from the database and how they are validated.
+* Each type wrapper must implement serialization, deserialization, and validation logic.
+*
+* @template T - The TypeScript type this wrapper represents.
+*/
 export class TypeWrapper {
     /** @internal Used for TypeScript type inference - this field is required for the type system */
     _T;
     constructor() { }
     /**
-     * Validate a value and serialize it, throwing on validation errors.
-     * @param obj - The object containing the value.
-     * @param prop - The property name or index.
-     * @param bytes - The Bytes instance to write to.
-     * @param model - Optional model instance for context.
-     * @throws {DatabaseError} If validation fails.
-     */
-    validateAndSerialize(obj, prop, bytes, model) {
-        const errors = this.getErrors(obj, prop);
-        if (errors.length)
-            throw errors[0];
-        this.serialize(obj, prop, bytes, model);
-    }
-    /**
-     * Serialize type metadata to bytes (for schema serialization).
-     * @param bytes - The Bytes instance to write to.
-     */
-    serializeType(bytes) { }
+    * Serialize type metadata to a Pack (for schema serialization).
+    * @param pack - The Pack instance to write to.
+    */
+    serializeType(pack) { }
     /**
-     * Check if indexing should be skipped for this field value.
-     * @param obj - The object containing the value.
-     * @param prop - The property name or index.
-     * @returns true if indexing should be skipped.
-     */
-    checkSkipIndex(obj, prop) {
+    * Check if indexing should be skipped for this field value.
+    * @param obj - The object containing the value.
+    * @param prop - The property name or index.
+    * @returns true if indexing should be skipped.
+    */
+    containsNull(value) {
         return false;
     }
     toString() {
         return `${this.kind}`;
     }
+    clone(value) {
+        return value;
+    }
+    equals(value1, value2) {
+        return value1 === value2;
+    }
+    getLinkedModel() {
+        return;
+    }
 }
-/**
- * @internal Type wrapper for string values.
- */
 class StringType extends TypeWrapper {
     kind = 'string';
-    serialize(obj, prop, bytes, model) {
-        bytes.writeString(obj[prop]);
+    serialize(value, pack) {
+        pack.write(value);
     }
-    deserialize(obj, prop, bytes, model) {
-        obj[prop] = bytes.readString();
+    deserialize(pack) {
+        return pack.readString();
     }
-    getErrors(obj, prop) {
-        if (typeof obj[prop] !== 'string') {
-            return [new DatabaseError(`Expected string, got ${typeof obj[prop]}`, 'INVALID_TYPE')];
+    getError(value) {
+        if (typeof value !== 'string') {
+            return new DatabaseError(`Expected string, got ${typeof value}`, 'INVALID_TYPE');
         }
-        return [];
     }
 }
-/**
- * @internal Type wrapper for number values.
- */
+class OrderedStringType extends StringType {
+    serialize(value, pack) {
+        pack.writeOrderedString(value);
+    }
+}
 class NumberType extends TypeWrapper {
     kind = 'number';
-    serialize(obj, prop, bytes, model) {
-        bytes.writeNumber(obj[prop]);
+    serialize(value, pack) {
+        pack.write(value);
     }
-    deserialize(obj, prop, bytes, model) {
-        obj[prop] = bytes.readNumber();
+    deserialize(pack) {
+        return pack.readNumber();
     }
-    getErrors(obj, prop) {
-        const value = obj[prop];
+    getError(value) {
         if (typeof value !== 'number' || isNaN(value)) {
-            return [new DatabaseError(`Expected number, got ${typeof value}`, 'INVALID_TYPE')];
+            return new DatabaseError(`Expected number, got ${typeof value}`, 'INVALID_TYPE');
         }
-        return [];
     }
 }
-/**
- * @internal Type wrapper for boolean values.
- */
+class DateTimeType extends TypeWrapper {
+    kind = 'dateTime';
+    serialize(value, pack) {
+        pack.write(value);
+    }
+    deserialize(pack) {
+        return pack.readDate();
+        ;
+    }
+    getError(value) {
+        if (!(value instanceof Date)) {
+            return new DatabaseError(`Expected Date, got ${typeof value}`, 'INVALID_TYPE');
+        }
+    }
+    default() {
+        return new Date();
+    }
+}
 class BooleanType extends TypeWrapper {
     kind = 'boolean';
-    serialize(obj, prop, bytes, model) {
-        bytes.writeBits(obj[prop] ? 1 : 0, 1);
+    serialize(value, pack) {
+        pack.write(value);
     }
-    deserialize(obj, prop, bytes, model) {
-        obj[prop] = bytes.readBits(1) === 1;
+    deserialize(pack) {
+        return pack.readBoolean();
     }
-    getErrors(obj, prop) {
-        if (typeof obj[prop] !== 'boolean') {
-            return [new DatabaseError(`Expected boolean, got ${typeof obj[prop]}`, 'INVALID_TYPE')];
+    getError(value) {
+        if (typeof value !== 'boolean') {
+            return new DatabaseError(`Expected boolean, got ${typeof value}`, 'INVALID_TYPE');
         }
-        return [];
     }
 }
 /**
- * @internal Type wrapper for array values with optional length constraints.
- * @template T - The type of array elements.
- */
+* @internal Type wrapper for array values with optional length constraints.
+* @template T - The type of array elements.
+*/
 class ArrayType extends TypeWrapper {
     inner;
     opts;
     kind = 'array';
     /**
-     * Create a new ArrayType.
-     * @param inner - Type wrapper for array elements.
-     * @param opts - Array constraints (min/max length).
-     */
+    * Create a new ArrayType.
+    * @param inner - Type wrapper for array elements.
+    * @param opts - Array constraints (min/max length).
+    */
     constructor(inner, opts = {}) {
         super();
         this.inner = inner;
         this.opts = opts;
     }
-    serialize(obj, prop, bytes, model) {
-        const value = obj[prop];
-        bytes.writeNumber(value.length);
+    serialize(value, pack) {
+        pack.write(value.length);
         for (let i = 0; i < value.length; i++) {
-            this.inner.serialize(value, i, bytes, model);
+            this.inner.serialize(value[i], pack);
         }
     }
-    deserialize(obj, prop, bytes, model) {
-        const length = bytes.readNumber();
+    deserialize(pack) {
+        const length = pack.readNumber();
         const result = [];
         for (let i = 0; i < length; i++) {
-            this.inner.deserialize(result, i, bytes, model);
+            result.push(this.inner.deserialize(pack));
         }
-        obj[prop] = result;
+        return result;
     }
-    getErrors(obj, prop) {
-        const value = obj[prop];
+    getError(value) {
         if (!Array.isArray(value)) {
-            return [new DatabaseError(`Expected array, got ${typeof value}`, 'INVALID_TYPE')];
+            return new DatabaseError(`Expected array, got ${typeof value}`, 'INVALID_TYPE');
         }
-        const errors = [];
         if (this.opts.min !== undefined && value.length < this.opts.min) {
-            errors.push(new DatabaseError(`Array length ${value.length} is less than minimum ${this.opts.min}`, 'OUT_OF_BOUNDS'));
+            return new DatabaseError(`Array length ${value.length} is less than minimum ${this.opts.min}`, 'OUT_OF_BOUNDS');
         }
         if (this.opts.max !== undefined && value.length > this.opts.max) {
-            errors.push(new DatabaseError(`Array length ${value.length} is greater than maximum ${this.opts.max}`, 'OUT_OF_BOUNDS'));
+            return new DatabaseError(`Array length ${value.length} is greater than maximum ${this.opts.max}`, 'OUT_OF_BOUNDS');
         }
         for (let i = 0; i < value.length; i++) {
-            for (let itemError of this.inner.getErrors(value, i)) {
-                errors.push(addErrorPath(itemError, i));
-            }
+            let error = this.inner.getError(value[i]);
+            if (error)
+                return addErrorPath(error, i);
         }
-        return errors;
     }
-    serializeType(bytes) {
-        serializeType(this.inner, bytes);
+    serializeType(pack) {
+        serializeType(this.inner, pack);
     }
-    static deserializeType(bytes, featureFlags) {
-        const inner = deserializeType(bytes, featureFlags);
+    static deserializeType(pack, featureFlags) {
+        const inner = deserializeType(pack, featureFlags);
         return new ArrayType(inner);
     }
+    default() {
+        return [];
+    }
+    clone(value) {
+        return value.map(this.inner.clone.bind(this.inner));
+    }
+    equals(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!this.inner.equals(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    toString() { return `array<${this.inner}>`; }
+    getLinkedModel() {
+        return this.inner.getLinkedModel();
+    }
 }
 /**
- * @internal Type wrapper for union/discriminated union types.
- * @template T - The union type this wrapper represents.
- */
+* @internal Type wrapper for array values with optional length constraints.
+* @template T - The type of array elements.
+*/
+export class SetType extends TypeWrapper {
+    inner;
+    opts;
+    kind = 'set';
+    /**
+    * Create a new SetType.
+    * @param inner - Type wrapper for set elements.
+    */
+    constructor(inner, opts = {}) {
+        super();
+        this.inner = inner;
+        this.opts = opts;
+    }
+    serialize(value, pack) {
+        pack.write(value.size);
+        for (const item of value) {
+            this.inner.serialize(item, pack);
+        }
+    }
+    deserialize(pack) {
+        const length = pack.readNumber();
+        const result = new Set();
+        for (let i = 0; i < length; i++) {
+            result.add(this.inner.deserialize(pack));
+        }
+        return result;
+    }
+    getError(value) {
+        if (!(value instanceof Set)) {
+            return new DatabaseError(`Expected Set, got ${typeof value}`, 'INVALID_TYPE');
+        }
+        if (this.opts.min !== undefined && value.size < this.opts.min) {
+            return new DatabaseError(`Set size ${value.size} is less than minimum ${this.opts.min}`, 'OUT_OF_BOUNDS');
+        }
+        if (this.opts.max !== undefined && value.size > this.opts.max) {
+            return new DatabaseError(`Set size ${value.size} is greater than maximum ${this.opts.max}`, 'OUT_OF_BOUNDS');
+        }
+        try {
+            for (const item of value) {
+                this.inner.getError(item);
+            }
+        }
+        catch (err) {
+            throw addErrorPath(err, 'item');
+        }
+    }
+    serializeType(pack) {
+        serializeType(this.inner, pack);
+    }
+    static deserializeType(pack, featureFlags) {
+        const inner = deserializeType(pack, featureFlags);
+        return new SetType(inner);
+    }
+    default() {
+        return new Set();
+    }
+    clone(value) {
+        const cloned = new Set();
+        for (const item of value) {
+            cloned.add(this.inner.clone(item));
+        }
+        return cloned;
+    }
+    equals(a, b) {
+        if (a.size !== b.size)
+            return false;
+        for (const v of a) {
+            if (!b.has(v))
+                return false;
+        }
+        return true;
+    }
+    toString() { return `set<${this.inner}>`; }
+    getLinkedModel() {
+        return this.inner.getLinkedModel();
+    }
+}
+/**
+* @internal Type wrapper for union/discriminated union types.
+* @template T - The union type this wrapper represents.
+*/
 class OrType extends TypeWrapper {
     choices;
     kind = 'or';
     /**
-     * Create a new OrType.
-     * @param choices - Array of type wrappers representing the union choices.
-     */
+    * Create a new OrType.
+    * @param choices - Array of type wrappers representing the union choices.
+    */
     constructor(choices) {
         super();
         this.choices = choices;
     }
-    _getChoiceIndex(obj, prop) {
+    _getChoiceIndex(value) {
         for (const [i, choice] of this.choices.entries()) {
-            if (choice.getErrors(obj, prop).length === 0) {
+            if (!choice.getError(value))
                 return i;
-            }
         }
-        throw new DatabaseError(`Value does not match any union type: ${obj[prop]}`, 'INVALID_TYPE');
+        throw new DatabaseError(`Value does not match any union type: ${value}`, 'INVALID_TYPE');
     }
-    serialize(obj, prop, bytes, model) {
-        const choiceIndex = this._getChoiceIndex(obj, prop);
-        bytes.writeUIntN(choiceIndex, this.choices.length - 1);
-        this.choices[choiceIndex].serialize(obj, prop, bytes, model);
+    serialize(value, pack) {
+        const choiceIndex = this._getChoiceIndex(value);
+        pack.write(choiceIndex);
+        this.choices[choiceIndex].serialize(value, pack);
     }
-    deserialize(obj, prop, bytes, model) {
-        const index = bytes.readUIntN(this.choices.length - 1);
+    deserialize(pack) {
+        const index = pack.readNumber();
         if (index < 0 || index >= this.choices.length) {
             throw new DatabaseError(`Could not deserialize invalid union index ${index}`, 'DESERIALIZATION_ERROR');
         }
         const type = this.choices[index];
-        type.deserialize(obj, prop, bytes, model);
-    }
-    getErrors(obj, prop) {
-        const errors = [];
-        for (let i = 0; i < this.choices.length; i++) {
-            const type = this.choices[i];
-            const subErrors = type.getErrors(obj, prop);
-            if (subErrors.length === 0)
-                return [];
-            for (let err of subErrors) {
-                errors.push(addErrorPath(err, `opt${i + 1}`));
-            }
+        return type.deserialize(pack);
+    }
+    getError(value) {
+        for (const choice of this.choices.values()) {
+            if (!choice.getError(value))
+                return;
         }
-        return errors;
+        return new DatabaseError(`Value does not match any union type: ${value}`, 'INVALID_TYPE');
     }
-    checkSkipIndex(obj, prop) {
-        const choiceIndex = this._getChoiceIndex(obj, prop);
-        return this.choices[choiceIndex].checkSkipIndex(obj, prop);
+    containsNull(value) {
+        const choiceIndex = this._getChoiceIndex(value);
+        return this.choices[choiceIndex].containsNull(value);
     }
-    serializeType(bytes) {
-        bytes.writeNumber(this.choices.length);
+    serializeType(pack) {
+        pack.write(this.choices.length);
         for (const choice of this.choices) {
-            serializeType(choice, bytes);
+            serializeType(choice, pack);
         }
     }
-    static deserializeType(bytes, featureFlags) {
-        const count = bytes.readNumber();
+    static deserializeType(pack, featureFlags) {
+        const count = pack.readNumber();
         const choices = [];
         for (let i = 0; i < count; i++) {
-            choices.push(deserializeType(bytes, featureFlags));
+            choices.push(deserializeType(pack, featureFlags));
         }
         return new OrType(choices);
     }
+    clone(value) {
+        const choiceIndex = this._getChoiceIndex(value);
+        return this.choices[choiceIndex].clone(value);
+    }
+    equals(a, b) {
+        const ca = this._getChoiceIndex(a);
+        const cb = this._getChoiceIndex(b);
+        return ca === cb && this.choices[ca].equals(a, b);
+    }
+    toString() { return `or<${this.choices.join('|')}>`; }
+    getLinkedModel() {
+        let model;
+        for (const choice of this.choices) {
+            const m = choice.getLinkedModel();
+            if (m) {
+                if (model && model !== m)
+                    throw new DatabaseError(`Union type has multiple linked models, unsupported by getLinkedModel()`, 'INVALID_TYPE');
+                model = m;
+            }
+        }
+        return model;
+    }
 }
 /**
- * @internal Type wrapper for literal values (constants).
- * @template T - The literal type this wrapper represents.
- */
+* @internal Type wrapper for literal values (constants).
+* @template T - The literal type this wrapper represents.
+*/
 class LiteralType extends TypeWrapper {
     value;
     kind = 'literal';
     /**
-     * Create a new LiteralType.
-     * @param value - The literal value this type represents.
-     */
+    * Create a new LiteralType.
+    * @param value - The literal value this type represents.
+    */
     constructor(value) {
         super();
         this.value = value;
     }
-    serialize(obj, prop, bytes, model) {
+    serialize(value, pack) {
         // Literal values don't need to be serialized since they're constants
     }
-    deserialize(obj, prop, bytes, model) {
-        obj[prop] = this.value;
+    deserialize(pack) {
+        return this.value;
     }
-    getErrors(obj, prop) {
-        return this.value === obj[prop] ? [] : [new DatabaseError(`Invalid literal value ${obj[prop]} instead of ${this.value}`, 'INVALID_TYPE')];
+    getError(value) {
+        if (this.value !== value) {
+            return new DatabaseError(`Invalid literal value ${value} instead of ${this.value}`, 'INVALID_TYPE');
+        }
     }
-    serializeType(bytes) {
-        bytes.writeString(this.value === undefined ? "" : JSON.stringify(this.value));
+    serializeType(pack) {
+        pack.write(this.value === undefined ? "" : JSON.stringify(this.value));
     }
-    checkSkipIndex(obj, prop) {
-        return obj[prop] == null;
+    containsNull(value) {
+        return value == null;
     }
-    static deserializeType(bytes, featureFlags) {
-        const json = bytes.readString();
+    static deserializeType(pack, featureFlags) {
+        const json = pack.readString();
         const value = json === "" ? undefined : JSON.parse(json);
         return new LiteralType(value);
     }
-    default(model) {
+    toString() { return `literal<${JSON.stringify(this.value)}>`; }
+    default() {
         return this.value;
     }
 }
-const ID_SIZE = 7;
+const ID_SIZE = 8;
 /**
- * @internal Type wrapper for auto-generated unique identifier strings.
- */
+* @internal Type wrapper for auto-generated unique identifier strings.
+*/
 class IdentifierType extends TypeWrapper {
     kind = 'id';
-    serialize(obj, prop, bytes) {
-        const value = obj[prop];
+    serialize(value, pack) {
         assert(value.length === ID_SIZE);
-        bytes.writeBase64(value);
+        pack.writeIdentifier(value);
     }
-    deserialize(obj, prop, bytes) {
-        obj[prop] = bytes.readBase64(ID_SIZE);
+    deserialize(pack) {
+        return pack.readIdentifier();
     }
-    getErrors(obj, prop) {
-        const value = obj[prop];
+    getError(value) {
         if (typeof value !== 'string' || value.length !== ID_SIZE)
-            return [new DatabaseError(`Invalid ID format: ${value}`, 'VALUE_ERROR')];
-        return [];
+            return new DatabaseError(`Invalid ID format: ${value}`, 'VALUE_ERROR');
     }
-    serializeType(bytes) {
+    serializeType(pack) {
     }
-    static deserializeType(bytes, featureFlags) {
+    static deserializeType(pack, featureFlags) {
         return new IdentifierType();
     }
     default(model) {
         // Generate a random ID, and if it already exists in the database, retry.
         let id;
         do {
-            // Combine a timestamp with randomness, to create locality of reference as well as a high chance of uniqueness.
-            // Bits 9...42 are the date (wrapping about four times a year)
-            // Bit 0...14 are random bits (partly overlapping with the date, adding up to 31ms of jitter)
-            let num = Math.floor(+new Date() * (1 << 9) + Math.random() * (1 << 14));
-            id = '';
-            for (let i = 0; i < 7; i++) {
-                id = Bytes.BASE64_CHARS[num & 0x3f] + id;
-                num = Math.floor(num / 64);
-            }
-        } while (olmdb.get(new Bytes().writeNumber(model.constructor._pk._cachedIndexId).writeBase64(id).getBuffer()));
+            id = DataPack.generateIdentifier();
+        } while (dbGet(model._txn.id, new DataPack().write(model.constructor._primary._indexId).writeIdentifier(id).toUint8Array()));
         return id;
     }
 }
-const WANT_PK_ARRAY = {};
 /**
- * @internal Type wrapper for model relationships (foreign keys).
- * @template T - The target model class type.
- */
+* @internal Type wrapper for model relationships (foreign keys).
+* @template T - The target model class type.
+*/
 export class LinkType extends TypeWrapper {
     kind = 'link';
-    TargetModel;
+    tableName;
     /**
-     * Create a new LinkType.
-     * @param TargetModel - The model class this link points to.
-     */
+    * Create a new LinkType.
+    * @param TargetModel - The model class this link points to.
+    */
     constructor(TargetModel) {
         super();
-        this.TargetModel = getMockModel(TargetModel);
-    }
-    serialize(obj, prop, bytes, model) {
-        let pkArray;
-        const pk = this.TargetModel._pk;
-        // If obj[prop] is getter(), it will return the primary key array (based on WANT_PK_ARRAY
-        // being the receiver). Otherwise, it will just return the value, which is a model instance.
-        let value = Reflect.get(obj, prop, WANT_PK_ARRAY);
-        if (value instanceof Array) {
-            // It's a pk array, and the object has not been loaded. We can just serialize it.
-            pk._serializeArgs(value, bytes);
-        }
-        else {
-            // It's a model instance that has been loaded
-            pk._serializeModel(value, bytes);
-        }
+        this.tableName = TargetModel.tableName || TargetModel.name;
     }
-    deserialize(obj, prop, bytes, sourceModel) {
-        const pk = this.TargetModel._pk;
-        const pkArray = pk._deserializeKey(bytes);
-        const TargetModel = this.TargetModel;
-        // Define a getter to load the model on first access
-        Object.defineProperty(obj, prop, {
-            get: function () {
-                // Special case to return the primary key array instead of load the model, used by serialize.
-                if (this === WANT_PK_ARRAY)
-                    return pkArray;
-                const targetModel = TargetModel._pk.get(...pkArray); // load by primary key Uint8Array
-                if (!targetModel) {
-                    throw new DatabaseError(`Linked ${TargetModel.tableName} instance ${pkArray.join(', ')} not found`, 'BROKEN_LINK');
-                }
-                this[prop] = targetModel; // Cause set() to be called, so our property will be come a regular value
-                return targetModel;
-            },
-            set: function (newValue) {
-                // Convert back to a regular value property
-                Object.defineProperty(this, prop, {
-                    value: newValue,
-                    writable: true,
-                    enumerable: true,
-                    configurable: true
-                });
-            },
-            enumerable: true,
-            configurable: true
-        });
-    }
-    getErrors(obj, prop) {
-        if (!(obj[prop] instanceof this.TargetModel)) {
-            return [new DatabaseError(`Expected instance of ${this.TargetModel.tableName}, got ${typeof obj[prop]}`, 'VALUE_ERROR')];
+    serialize(model, pack) {
+        pack.write(model.getPrimaryKey());
+    }
+    deserialize(pack) {
+        return modelRegistry[this.tableName]._primary._get(currentTxn(), pack.readUint8Array(), false);
+    }
+    getError(value) {
+        if (!(value instanceof modelRegistry[this.tableName])) {
+            return new DatabaseError(`Expected instance of ${this.tableName}, got ${typeof value}`, 'VALUE_ERROR');
         }
-        return [];
     }
-    serializeType(bytes) {
-        bytes.writeString(this.TargetModel.tableName);
+    serializeType(pack) {
+        pack.write(this.tableName);
     }
-    static deserializeType(bytes, featureFlags) {
-        const tableName = bytes.readString();
+    static deserializeType(pack, featureFlags) {
+        const tableName = pack.readString();
         const targetModel = modelRegistry[tableName];
         if (!targetModel)
             throw new DatabaseError(`Could not deserialize undefined model ${tableName}`, 'DESERIALIZATION_ERROR');
         return new LinkType(targetModel);
     }
+    toString() { return `link<${this.tableName}>`; }
+    getLinkedModel() {
+        return modelRegistry[this.tableName];
+    }
 }
-/** Constant representing the string type. */
+/** Type wrapper instance for the string type. */
 export const string = new StringType();
-/** Constant representing the number type. */
+/** Type wrapper instance for the ordered string type, which is just like a string
+ * except that it sorts lexicographically in the database (instead of by incrementing
+ * length first), making it suitable for index fields that want lexicographic range
+ * scans. Ordered strings are implemented as null-terminated UTF-8 strings, so they
+ * may not contain null characters.
+ */
+export const orderedString = new OrderedStringType();
+/** Type wrapper instance for the number type. */
 export const number = new NumberType();
-/** Constant representing the boolean type. */
+/** Type wrapper instance for the date/time type. */
+export const dateTime = new DateTimeType();
+/** Type wrapper instance for the boolean type. */
 export const boolean = new BooleanType();
-/** Constant representing the identifier type. */
+/** Type wrapper instance for the identifier type. */
 export const identifier = new IdentifierType();
+/** Type wrapper instance for the 'undefined' type. */
+export const undef = new LiteralType(undefined);
 /**
- * Create a literal type wrapper for a constant value.
- * @template T - The literal type.
- * @param value - The literal value.
- * @returns A literal type instance.
- *
- * @example
- * ```typescript
- * const statusType = E.literal("active");
- * const countType = E.literal(42);
- * ```
- */
+* Create a literal type wrapper for a constant value.
+* @template T - The literal type.
+* @param value - The literal value.
+* @returns A literal type instance.
+*
+* @example
+* ```typescript
+* const statusType = E.literal("active");
+* const countType = E.literal(42);
+* ```
+*/
 export function literal(value) {
     return new LiteralType(value);
 }
 /**
- * Create a union type wrapper from multiple type choices.
- * @template T - Array of type wrapper or basic types.
- * @param choices - The type choices for the union.
- * @returns A union type instance.
- *
- * @example
- * ```typescript
- * const stringOrNumber = E.or(E.string, E.number);
- * const status = E.or("active", "inactive", "pending");
- * ```
- */
+* Create a union type wrapper from multiple type choices.
+* @template T - Array of type wrapper or basic types.
+* @param choices - The type choices for the union.
+* @returns A union type instance.
+*
+* @example
+* ```typescript
+* const stringOrNumber = E.or(E.string, E.number);
+* const status = E.or("active", "inactive", "pending");
+* ```
+*/
 export function or(...choices) {
     return new OrType(choices.map(wrapIfLiteral));
 }
-/** Constant representing the 'undefined' type. */
-export const undef = new LiteralType(undefined);
 /**
- * Create an optional type wrapper (allows undefined).
- * @template T - Type wrapper or basic type to make optional.
- * @param inner - The inner type to make optional.
- * @returns A union type that accepts the inner type or undefined.
- *
- * @example
- * ```typescript
- * const optionalString = E.opt(E.string);
- * const optionalNumber = E.opt(E.number);
- * ```
- */
+* Create an optional type wrapper (allows undefined).
+* @template T - Type wrapper or basic type to make optional.
+* @param inner - The inner type to make optional.
+* @returns A union type that accepts the inner type or undefined.
+*
+* @example
+* ```typescript
+* const optionalString = E.opt(E.string);
+* const optionalNumber = E.opt(E.number);
+* ```
+*/
 export function opt(inner) {
     return or(undef, inner);
 }
 /**
- * Create an array type wrapper with optional length constraints.
- * @template T - The element type.
- * @param inner - Type wrapper for array elements.
- * @param opts - Optional constraints (min/max length).
- * @returns An array type instance.
- *
- * @example
- * ```typescript
- * const stringArray = E.array(E.string);
- * const boundedArray = E.array(E.number, {min: 1, max: 10});
- * ```
- */
+* Create an array type wrapper with optional length constraints.
+* @template T - The element type.
+* @param inner - Type wrapper for array elements.
+* @param opts - Optional constraints (min/max length).
+* @returns An array type instance.
+*
+* @example
+* ```typescript
+* const stringArray = E.array(E.string);
+* const boundedArray = E.array(E.number, {min: 1, max: 10});
+* ```
+*/
 export function array(inner, opts = {}) {
     return new ArrayType(wrapIfLiteral(inner), opts);
 }
 /**
- * Create a link type wrapper for model relationships.
- * @template T - The target model class.
- * @param TargetModel - The model class this link points to.
- * @returns A link type instance.
- *
- * @example
- * ```typescript
- * class User extends E.Model<User> {
- *   posts = E.field(E.array(E.link(Post, 'author')));
- * }
- *
- * class Post extends E.Model<Post> {
- *   author = E.field(E.link(User));
- * }
- * ```
- */
+* Create a Set type wrapper with optional length constraints.
+* @template T - The element type.
+* @param inner - Type wrapper for set elements.
+* @param opts - Optional constraints (min/max length).
+* @returns A set type instance.
+*
+* @example
+* ```typescript
+* const stringSet = E.set(E.string);
+* const boundedSet = E.set(E.number, {min: 1, max: 10});
+* ```
+*/
+export function set(inner, opts = {}) {
+    return new SetType(wrapIfLiteral(inner), opts);
+}
+/**
+* Create a link type wrapper for model relationships.
+* @template T - The target model class.
+* @param TargetModel - The model class this link points to.
+* @returns A link type instance.
+*
+* @example
+* ```typescript
+* class User extends E.Model<User> {
+*   posts = E.field(E.array(E.link(Post, 'author')));
+* }
+*
+* class Post extends E.Model<Post> {
+*   author = E.field(E.link(User));
+* }
+* ```
+*/
 export function link(TargetModel) {
     return new LinkType(TargetModel);
 }
@@ -485,35 +580,39 @@ function wrapIfLiteral(type) {
     return type instanceof TypeWrapper ? type : new LiteralType(type);
 }
 /**
- * Serialize a type wrapper to bytes for schema persistence.
- * @param arg - The type wrapper to serialize.
- * @param bytes - The Bytes instance to write to.
- */
-export function serializeType(arg, bytes) {
-    bytes.writeString(arg.kind);
-    arg.serializeType(bytes);
+* Serialize a type wrapper to a Pack for schema persistence.
+* @param arg - The type wrapper to serialize.
+* @param pack - The Pack instance to write to.
+*/
+export function serializeType(arg, pack) {
+    pack.write(arg.kind);
+    arg.serializeType(pack);
 }
 const TYPE_WRAPPERS = {
     string: string,
     number: number,
+    dateTime: dateTime,
+    boolean: boolean,
     array: ArrayType,
+    set: SetType,
     or: OrType,
     literal: LiteralType,
-    boolean: boolean,
     id: identifier,
     link: LinkType,
 };
 /**
- * Deserialize a type wrapper from bytes.
- * @param bytes - The Bytes instance to read from.
- * @param featureFlags - Feature flags for version compatibility.
- * @returns The deserialized type wrapper.
- */
-export function deserializeType(bytes, featureFlags) {
-    const kind = bytes.readString();
+* Deserialize a type wrapper from a Pack.
+* @param pack - The Pack instance to read from.
+* @param featureFlags - Feature flags for version compatibility.
+* @returns The deserialized type wrapper.
+*/
+export function deserializeType(pack, featureFlags) {
+    const kind = pack.readString();
     const TypeWrapper = TYPE_WRAPPERS[kind];
+    if (!TypeWrapper)
+        throw new DatabaseError(`Unknown field type in database: ${kind}`, 'CONSISTENCY_ERROR');
     if ('deserializeType' in TypeWrapper) {
-        return TypeWrapper.deserializeType(bytes, featureFlags);
+        return TypeWrapper.deserializeType(pack, featureFlags);
     }
     else {
         return TypeWrapper;