@reifydb/core 0.9.3 → 0.10.0

package/dist/index.js

@@ -21,29 +21,28 @@ var ROW_NUMBER_KEY = "#rownum";
 var BlobValue = class _BlobValue {
   constructor(value) {
     this.type = "Blob";
-    if (value !== void 0) {
-      if (value instanceof Uint8Array) {
-        this.bytes = new Uint8Array(value);
-      } else if (value instanceof ArrayBuffer) {
-        this.bytes = new Uint8Array(value);
-      } else if (typeof value === "string") {
-        const parsed = _BlobValue.parseString(value);
-        if (parsed === null) {
-          throw new Error(`Invalid blob string: ${value}`);
-        }
-        this.bytes = parsed;
-      } else if (Array.isArray(value)) {
-        for (const byte of value) {
-          if (!Number.isInteger(byte) || byte < 0 || byte > 255) {
-            throw new Error(`Invalid byte value: ${byte}`);
-          }
+    if (value === void 0) {
+      throw new Error(`Blob value must be defined, a none is carried by NoneValue`);
+    }
+    if (value instanceof Uint8Array) {
+      this.bytes = new Uint8Array(value);
+    } else if (value instanceof ArrayBuffer) {
+      this.bytes = new Uint8Array(value);
+    } else if (typeof value === "string") {
+      const parsed = _BlobValue.parseString(value);
+      if (parsed === null) {
+        throw new Error(`Invalid blob string: ${value}`);
+      }
+      this.bytes = parsed;
+    } else if (Array.isArray(value)) {
+      for (const byte of value) {
+        if (!Number.isInteger(byte) || byte < 0 || byte > 255) {
+          throw new Error(`Invalid byte value: ${byte}`);
         }
-        this.bytes = new Uint8Array(value);
-      } else {
-        throw new Error(`Blob value must be a Uint8Array, ArrayBuffer, string, or number[], got ${typeof value}`);
       }
+      this.bytes = new Uint8Array(value);
     } else {
-      this.bytes = void 0;
+      throw new Error(`Blob value must be a Uint8Array, ArrayBuffer, string, or number[], got ${typeof value}`);
     }
   }
   /**
@@ -67,8 +66,8 @@ var BlobValue = class _BlobValue {
   /**
    * Create a BLOB from a hex string
    */
-  static fromHex(hex) {
-    const cleanHex = hex.startsWith("0x") || hex.startsWith("0X") ? hex.substring(2) : hex;
+  static fromHex(hex2) {
+    const cleanHex = hex2.startsWith("0x") || hex2.startsWith("0X") ? hex2.substring(2) : hex2;
     if (cleanHex.length % 2 !== 0) {
       throw new Error(`Invalid hex string: odd length`);
     }
@@ -76,7 +75,7 @@ var BlobValue = class _BlobValue {
     for (let i = 0; i < cleanHex.length; i += 2) {
       const byte = parseInt(cleanHex.substring(i, i + 2), 16);
       if (isNaN(byte)) {
-        throw new Error(`Invalid hex string: ${hex}`);
+        throw new Error(`Invalid hex string: ${hex2}`);
       }
       bytes[i / 2] = byte;
     }
@@ -118,7 +117,7 @@ var BlobValue = class _BlobValue {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _BlobValue(void 0);
+      throw new Error(`Cannot parse "${str}" as Blob`);
     }
     const parsed = _BlobValue.parseString(trimmed);
     if (parsed === null) {
@@ -149,8 +148,8 @@ var BlobValue = class _BlobValue {
    */
   toHex() {
     if (this.bytes === void 0) return void 0;
-    const hex = Array.from(this.bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-    return "0x" + hex;
+    const hex2 = Array.from(this.bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    return "0x" + hex2;
   }
   /**
    * Convert to base64 string
@@ -176,13 +175,10 @@ var BlobValue = class _BlobValue {
    * Format as hex string with 0x prefix
    */
   toString() {
-    if (this.bytes === void 0) {
-      return "none";
-    }
     return this.toHex();
   }
   valueOf() {
-    return this.bytes ? new Uint8Array(this.bytes) : void 0;
+    return new Uint8Array(this.bytes);
   }
   /**
    * Get the internal representation
@@ -232,12 +228,12 @@ var BlobValue = class _BlobValue {
     return null;
   }
   toJSON() {
-    return this.bytes === void 0 ? null : this.toHex();
+    return this.toHex();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -246,19 +242,18 @@ var BlobValue = class _BlobValue {
 var BooleanValue = class _BooleanValue {
   constructor(value) {
     this.type = "Boolean";
-    if (value !== void 0) {
-      if (typeof value !== "boolean") {
-        throw new Error(`Boolean value must be a boolean, got ${typeof value}`);
-      }
-      this.value = value;
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`Boolean value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value !== "boolean") {
+      throw new Error(`Boolean value must be a boolean, got ${typeof value}`);
     }
+    this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim().toLowerCase();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _BooleanValue(void 0);
+      throw new Error(`Cannot parse "${str}" as Boolean`);
     }
     if (trimmed === "true") {
       return new _BooleanValue(true);
@@ -272,7 +267,7 @@ var BooleanValue = class _BooleanValue {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two boolean values for equality
@@ -290,43 +285,43 @@ var BooleanValue = class _BooleanValue {
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
 
 // src/value/date.ts
 var DateValue = class _DateValue {
-  // day of month (1-31)
   constructor(value) {
     this.type = "Date";
-    if (value !== void 0) {
-      if (value instanceof Date) {
-        const year = value.getUTCFullYear();
-        const month = value.getUTCMonth() + 1;
-        const day = value.getUTCDate();
-        this.months = year * 12 + (month - 1);
-        this.days = day;
-      } else if (typeof value === "string") {
-        const parsed = _DateValue.parseDate(value);
-        if (!parsed) {
-          throw new Error(`Invalid date string: ${value}`);
-        }
-        this.months = parsed.months;
-        this.days = parsed.days;
-      } else if (typeof value === "number") {
-        const date = _DateValue.fromDaysSinceEpochToComponents(value);
-        if (!date) {
-          throw new Error(`Invalid days since epoch: ${value}`);
-        }
-        this.months = date.months;
-        this.days = date.days;
-      } else {
-        throw new Error(`Date value must be a Date, string, or number, got ${typeof value}`);
+    if (value === void 0) {
+      throw new Error(`Date value must be defined, a none is carried by NoneValue`);
+    }
+    if (value instanceof Date) {
+      const year = value.getUTCFullYear();
+      const month = value.getUTCMonth() + 1;
+      const day = value.getUTCDate();
+      this.months = year * 12 + (month - 1);
+      this.days = day;
+    } else if (typeof value === "string") {
+      const parsed = _DateValue.parseDate(value);
+      if (!parsed) {
+        throw new Error(`Invalid date string: ${value}`);
       }
+      this.months = parsed.months;
+      this.days = parsed.days;
+    } else if (typeof value === "number") {
+      const date = _DateValue.fromDaysSinceEpochToComponents(value);
+      if (!date) {
+        throw new Error(`Invalid days since epoch: ${value}`);
+      }
+      this.months = date.months;
+      this.days = date.days;
+    } else if (typeof value === "object" && "months" in value && "days" in value) {
+      this.months = value.months;
+      this.days = value.days;
     } else {
-      this.months = void 0;
-      this.days = void 0;
+      throw new Error(`Date value must be a Date, string, or number, got ${typeof value}`);
     }
   }
   /**
@@ -336,10 +331,7 @@ var DateValue = class _DateValue {
     if (!_DateValue.isValidDate(year, month, day)) {
       throw new Error(`Invalid date: ${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`);
     }
-    const result = new _DateValue(void 0);
-    result.months = year * 12 + (month - 1);
-    result.days = day;
-    return result;
+    return new _DateValue({ months: year * 12 + (month - 1), days: day });
   }
   /**
    * Get today's date (in UTC)
@@ -358,16 +350,13 @@ var DateValue = class _DateValue {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _DateValue(void 0);
+      throw new Error(`Cannot parse "${str}" as Date`);
     }
     const parsed = _DateValue.parseDate(trimmed);
     if (!parsed) {
       throw new Error(`Cannot parse "${str}" as Date`);
     }
-    const result = new _DateValue(void 0);
-    result.months = parsed.months;
-    result.days = parsed.days;
-    return result;
+    return new _DateValue(parsed);
   }
   /**
    * Convert to days since Unix epoch (1970-01-01) for storage
@@ -542,29 +531,28 @@ var DateValue = class _DateValue {
 var _TimeValue = class _TimeValue {
   constructor(value) {
     this.type = "Time";
-    if (value !== void 0) {
-      if (typeof value === "bigint") {
-        if (value < 0n || value >= _TimeValue.NANOS_PER_DAY) {
-          throw new Error(`Time value must be between 0 and ${_TimeValue.NANOS_PER_DAY - 1n} nanoseconds`);
-        }
-        this.value = value;
-      } else if (typeof value === "string") {
-        const parsed = _TimeValue.parseTime(value);
-        if (parsed === null) {
-          throw new Error(`Invalid time string: ${value}`);
-        }
-        this.value = parsed;
-      } else if (typeof value === "number") {
-        const bigintValue = BigInt(Math.floor(value));
-        if (bigintValue < 0n || bigintValue >= _TimeValue.NANOS_PER_DAY) {
-          throw new Error(`Time value must be between 0 and ${_TimeValue.NANOS_PER_DAY - 1n} nanoseconds`);
-        }
-        this.value = bigintValue;
-      } else {
-        throw new Error(`Time value must be a bigint, string, or number, got ${typeof value}`);
+    if (value === void 0) {
+      throw new Error(`Time value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value === "bigint") {
+      if (value < 0n || value >= _TimeValue.NANOS_PER_DAY) {
+        throw new Error(`Time value must be between 0 and ${_TimeValue.NANOS_PER_DAY - 1n} nanoseconds`);
       }
+      this.value = value;
+    } else if (typeof value === "string") {
+      const parsed = _TimeValue.parseTime(value);
+      if (parsed === null) {
+        throw new Error(`Invalid time string: ${value}`);
+      }
+      this.value = parsed;
+    } else if (typeof value === "number") {
+      const bigintValue = BigInt(Math.floor(value));
+      if (bigintValue < 0n || bigintValue >= _TimeValue.NANOS_PER_DAY) {
+        throw new Error(`Time value must be between 0 and ${_TimeValue.NANOS_PER_DAY - 1n} nanoseconds`);
+      }
+      this.value = bigintValue;
     } else {
-      this.value = void 0;
+      throw new Error(`Time value must be a bigint, string, or number, got ${typeof value}`);
     }
   }
   /**
@@ -610,7 +598,7 @@ var _TimeValue = class _TimeValue {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _TimeValue(void 0);
+      throw new Error(`Cannot parse "${str}" as Time`);
     }
     const parsed = _TimeValue.parseTime(trimmed);
     if (parsed === null) {
@@ -665,9 +653,6 @@ var _TimeValue = class _TimeValue {
    * Format as HH:MM:SS.nnnnnnnnn string
    */
   toString() {
-    if (this.value === void 0) {
-      return "none";
-    }
     const hour = this.hour();
     const minute = this.minute();
     const second = this.second();
@@ -720,12 +705,12 @@ var _TimeValue = class _TimeValue {
     return this.value === otherTime.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.toString();
+    return this.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -741,59 +726,60 @@ var DateTimeValue = class _DateTimeValue {
   // nanoseconds since midnight
   constructor(value) {
     this.type = "DateTime";
-    if (value !== void 0) {
-      if (value instanceof Date) {
-        const year = value.getUTCFullYear();
-        const month = value.getUTCMonth() + 1;
-        const day = value.getUTCDate();
-        const hour = value.getUTCHours();
-        const minute = value.getUTCMinutes();
-        const second = value.getUTCSeconds();
-        const millis = value.getUTCMilliseconds();
-        this.months = year * 12 + (month - 1);
-        this.days = day;
-        this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(millis) * 1000000n;
-      } else if (typeof value === "string") {
-        const parsed = _DateTimeValue.parseDateTime(value);
-        if (!parsed) {
-          throw new Error(`Invalid datetime string: ${value}`);
-        }
-        this.months = parsed.months;
-        this.days = parsed.days;
-        this.nanos = parsed.nanos;
-      } else if (typeof value === "number") {
-        const date = new Date(value);
-        const year = date.getUTCFullYear();
-        const month = date.getUTCMonth() + 1;
-        const day = date.getUTCDate();
-        const hour = date.getUTCHours();
-        const minute = date.getUTCMinutes();
-        const second = date.getUTCSeconds();
-        const millis = date.getUTCMilliseconds();
-        this.months = year * 12 + (month - 1);
-        this.days = day;
-        this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(millis) * 1000000n;
-      } else if (typeof value === "bigint") {
-        const millis = Number(value / 1000000n);
-        const extraNanos = value % 1000000n;
-        const date = new Date(millis);
-        const year = date.getUTCFullYear();
-        const month = date.getUTCMonth() + 1;
-        const day = date.getUTCDate();
-        const hour = date.getUTCHours();
-        const minute = date.getUTCMinutes();
-        const second = date.getUTCSeconds();
-        const dateMillis = date.getUTCMilliseconds();
-        this.months = year * 12 + (month - 1);
-        this.days = day;
-        this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(dateMillis) * 1000000n + extraNanos;
-      } else {
-        throw new Error(`DateTime value must be a Date, string, number, or bigint, got ${typeof value}`);
+    if (value === void 0) {
+      throw new Error(`DateTime value must be defined, a none is carried by NoneValue`);
+    }
+    if (value instanceof Date) {
+      const year = value.getUTCFullYear();
+      const month = value.getUTCMonth() + 1;
+      const day = value.getUTCDate();
+      const hour = value.getUTCHours();
+      const minute = value.getUTCMinutes();
+      const second = value.getUTCSeconds();
+      const millis = value.getUTCMilliseconds();
+      this.months = year * 12 + (month - 1);
+      this.days = day;
+      this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(millis) * 1000000n;
+    } else if (typeof value === "string") {
+      const parsed = _DateTimeValue.parseDateTime(value);
+      if (!parsed) {
+        throw new Error(`Invalid datetime string: ${value}`);
       }
+      this.months = parsed.months;
+      this.days = parsed.days;
+      this.nanos = parsed.nanos;
+    } else if (typeof value === "number") {
+      const date = new Date(value);
+      const year = date.getUTCFullYear();
+      const month = date.getUTCMonth() + 1;
+      const day = date.getUTCDate();
+      const hour = date.getUTCHours();
+      const minute = date.getUTCMinutes();
+      const second = date.getUTCSeconds();
+      const millis = date.getUTCMilliseconds();
+      this.months = year * 12 + (month - 1);
+      this.days = day;
+      this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(millis) * 1000000n;
+    } else if (typeof value === "bigint") {
+      const millis = Number(value / 1000000n);
+      const extraNanos = value % 1000000n;
+      const date = new Date(millis);
+      const year = date.getUTCFullYear();
+      const month = date.getUTCMonth() + 1;
+      const day = date.getUTCDate();
+      const hour = date.getUTCHours();
+      const minute = date.getUTCMinutes();
+      const second = date.getUTCSeconds();
+      const dateMillis = date.getUTCMilliseconds();
+      this.months = year * 12 + (month - 1);
+      this.days = day;
+      this.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(dateMillis) * 1000000n + extraNanos;
+    } else if (typeof value === "object" && "months" in value && "days" in value && "nanos" in value) {
+      this.months = value.months;
+      this.days = value.days;
+      this.nanos = value.nanos;
     } else {
-      this.months = void 0;
-      this.days = void 0;
-      this.nanos = void 0;
+      throw new Error(`DateTime value must be a Date, string, number, or bigint, got ${typeof value}`);
     }
   }
   /**
@@ -815,11 +801,11 @@ var DateTimeValue = class _DateTimeValue {
     if (!_DateTimeValue.isValidDate(year, month, day)) {
       throw new Error(`Invalid datetime: ${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")} ${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}:${String(second).padStart(2, "0")}`);
     }
-    const result = new _DateTimeValue(void 0);
-    result.months = year * 12 + (month - 1);
-    result.days = day;
-    result.nanos = BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(nano);
-    return result;
+    return new _DateTimeValue({
+      months: year * 12 + (month - 1),
+      days: day,
+      nanos: BigInt(hour) * 3600000000000n + BigInt(minute) * 60000000000n + BigInt(second) * 1000000000n + BigInt(nano)
+    });
   }
   /**
    * Create a DateTimeValue from year, month, day, hour, minute, second (no fractional)
@@ -855,10 +841,11 @@ var DateTimeValue = class _DateTimeValue {
     const millis = seconds * 1e3 + Math.floor(nanos / 1e6);
     const extraNanos = nanos % 1e6;
     const result = new _DateTimeValue(millis);
-    if (result.nanos !== void 0) {
-      result.nanos = result.nanos + BigInt(extraNanos);
-    }
-    return result;
+    return new _DateTimeValue({
+      months: result.months,
+      days: result.days,
+      nanos: result.nanos + BigInt(extraNanos)
+    });
   }
   /**
    * Get current datetime
@@ -878,17 +865,13 @@ var DateTimeValue = class _DateTimeValue {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _DateTimeValue(void 0);
+      throw new Error(`Cannot parse "${str}" as DateTime`);
     }
     const parsed = _DateTimeValue.parseDateTime(trimmed);
     if (!parsed) {
       throw new Error(`Cannot parse "${str}" as DateTime`);
     }
-    const result = new _DateTimeValue(void 0);
-    result.months = parsed.months;
-    result.days = parsed.days;
-    result.nanos = parsed.nanos;
-    return result;
+    return new _DateTimeValue(parsed);
   }
   /**
    * Get Unix timestamp in seconds
@@ -977,9 +960,6 @@ var DateTimeValue = class _DateTimeValue {
     return `${yearStr}-${month}-${day}T${hour}:${minute}:${second}.${nanoStr}Z`;
   }
   valueOf() {
-    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
-      return void 0;
-    }
     const year = Math.floor(this.months / 12);
     let m = this.months % 12;
     if (m < 0) m += 12;
@@ -1075,35 +1055,32 @@ var DateTimeValue = class _DateTimeValue {
     return this.months === otherDateTime.months && this.days === otherDateTime.days && this.nanos === otherDateTime.nanos;
   }
   toJSON() {
-    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
-      return null;
-    }
     return this.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
 
 // src/value/decimal.ts
+var DECIMAL_PATTERN = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/;
 var DecimalValue = class _DecimalValue {
   constructor(value) {
     this.type = "Decimal";
-    if (value !== void 0) {
-      if (typeof value !== "string") {
-        throw new Error(`Decimal value must be a string, got ${typeof value}`);
-      }
-      this.value = value;
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`Decimal value must be defined, a none is carried by NoneValue`);
     }
+    if (typeof value !== "string") {
+      throw new Error(`Decimal value must be a string, got ${typeof value}`);
+    }
+    this.value = value;
   }
   static parse(str) {
-    if (str === NONE_VALUE) {
-      return new _DecimalValue(void 0);
+    if (!DECIMAL_PATTERN.test(str)) {
+      throw new Error(`Cannot parse "${str}" as Decimal`);
     }
     return new _DecimalValue(str);
   }
@@ -1111,7 +1088,7 @@ var DecimalValue = class _DecimalValue {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value;
+    return this.value;
   }
   equals(other) {
     if (other.type !== this.type) {
@@ -1126,45 +1103,314 @@ var DecimalValue = class _DecimalValue {
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
 
-// src/value/float4.ts
-var _Float4Value = class _Float4Value {
-  constructor(value) {
-    this.type = "Float4";
-    if (value !== void 0) {
-      if (typeof value !== "number") {
-        throw new Error(`Float4 value must be a number, got ${typeof value}`);
+// src/type-code.ts
+var TYPE_CODE = {
+  None: 0,
+  Boolean: 1,
+  Float4: 2,
+  Float8: 3,
+  Int1: 4,
+  Int2: 5,
+  Int4: 6,
+  Int8: 7,
+  Int16: 8,
+  Utf8: 9,
+  Uint1: 10,
+  Uint2: 11,
+  Uint4: 12,
+  Uint8: 13,
+  Uint16: 14,
+  Date: 15,
+  DateTime: 16,
+  Time: 17,
+  Duration: 18,
+  IdentityId: 19,
+  Uuid4: 20,
+  Uuid7: 21,
+  Blob: 22,
+  Decimal: 23,
+  Any: 24,
+  DictionaryId: 25,
+  Type: 26,
+  List: 27,
+  Record: 28,
+  Tuple: 29,
+  Digest: 30
+};
+var CODE_TO_NAME = Object.fromEntries(
+  Object.entries(TYPE_CODE).map(([k, v]) => [v, k])
+);
+function typeNameFromCode(code) {
+  const name = CODE_TO_NAME[code];
+  if (!name) throw new Error(`Unknown type code: ${code}`);
+  return name;
+}
+
+// src/value/digest.ts
+var VERSION = 1n;
+var MIN_ACCURACY = 1e3;
+var MAX_ACCURACY = 1e5;
+var U32_MAX = 0xffffffffn;
+var U64_MAX = 0xffffffffffffffffn;
+var I32_MAX = 0x7fffffffn;
+var INNER_TYPES = [
+  "Float4",
+  "Float8",
+  "Int1",
+  "Int2",
+  "Int4",
+  "Int8",
+  "Int16",
+  "Uint1",
+  "Uint2",
+  "Uint4",
+  "Uint8",
+  "Uint16",
+  "Duration"
+];
+function digestType(inner, accuracy) {
+  const supported = INNER_TYPES.find((name) => name === inner);
+  if (supported === void 0) {
+    throw new Error(`digest does not support ${inner} input`);
+  }
+  if (!Number.isInteger(accuracy) || accuracy < MIN_ACCURACY || accuracy > MAX_ACCURACY) {
+    throw new Error(`digest accuracy must be a whole number of ppm between ${MIN_ACCURACY} and ${MAX_ACCURACY}, got ${accuracy}`);
+  }
+  return { Digest: { inner: supported, accuracy } };
+}
+function digestTypeName(type) {
+  const { inner, accuracy } = type.Digest;
+  const whole = Math.floor(accuracy / 1e6);
+  const fraction = accuracy % 1e6;
+  const text = fraction === 0 ? `${whole}` : `${whole}.${String(fraction).padStart(6, "0").replace(/0+$/, "")}`;
+  return `Digest(${inner}, ${text})`;
+}
+var DigestValue = class _DigestValue {
+  constructor(bytes) {
+    const reader = new DigestReader(bytes);
+    const decoded = reader.digest();
+    this.bytes = new Uint8Array(bytes);
+    this.type = decoded.type;
+    this.inner = decoded.type.Digest.inner;
+    this.accuracy = decoded.type.Digest.accuracy;
+    this.count = decoded.count;
+  }
+  static parse(str, type) {
+    if (!/^0x([0-9a-fA-F]{2})*$/.test(str)) {
+      throw new Error(`Cannot parse "${str}" as ${digestTypeName(type)}`);
+    }
+    const bytes = new Uint8Array((str.length - 2) / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(str.substring(2 + i * 2, 4 + i * 2), 16);
+    }
+    const digest = new _DigestValue(bytes);
+    if (digest.inner !== type.Digest.inner || digest.accuracy !== type.Digest.accuracy) {
+      throw new Error(`digest is ${digestTypeName(digest.type)} but the type is ${digestTypeName(type)}`);
+    }
+    return digest;
+  }
+  asBytes() {
+    return new Uint8Array(this.bytes);
+  }
+  toString() {
+    return `digest(n: ${this.count})`;
+  }
+  equals(other) {
+    if (!(other instanceof _DigestValue) || other.bytes.length !== this.bytes.length) {
+      return false;
+    }
+    return this.bytes.every((byte, i) => byte === other.bytes[i]);
+  }
+  toJSON() {
+    return hex(this.bytes);
+  }
+  encode() {
+    return {
+      type: this.type,
+      value: hex(this.bytes)
+    };
+  }
+};
+function hex(bytes) {
+  return "0x" + Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var DigestReader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.position = 0;
+  }
+  digest() {
+    const version4 = this.varint();
+    if (version4 !== VERSION) {
+      throw new Error(`digest encoding version ${version4} is unknown`);
+    }
+    const tag = this.varint();
+    const inner = INNER_TYPES.find((name) => BigInt(TYPE_CODE[name]) === tag);
+    if (inner === void 0) {
+      throw new Error(`digest encoding has unknown inner type tag ${tag}`);
+    }
+    const accuracy = this.varint();
+    if (accuracy > U32_MAX) {
+      throw new Error(`digest accuracy must be a whole number of ppm between ${MIN_ACCURACY} and ${MAX_ACCURACY}, got ${accuracy}`);
+    }
+    const type = digestType(inner, Number(accuracy));
+    const zero = this.varint();
+    const negativeInfinity = this.varint();
+    const positiveInfinity = this.varint();
+    const negative = this.store();
+    const positive = this.store();
+    if (this.position !== this.bytes.length) {
+      throw new Error(`digest encoding has ${this.bytes.length - this.position} trailing bytes`);
+    }
+    if (inner === "Duration" && (negativeInfinity !== 0n || positiveInfinity !== 0n)) {
+      throw new Error("digest of duration cannot hold infinity");
+    }
+    const count = zero + negativeInfinity + positiveInfinity + negative + positive;
+    if (count > U64_MAX) {
+      throw new Error("digest encoding counts overflow u64");
+    }
+    return { type, count };
+  }
+  varint() {
+    let value = 0n;
+    let shift = 0n;
+    for (; ; ) {
+      if (this.position >= this.bytes.length) {
+        throw new Error("digest encoding ends early");
+      }
+      const byte = this.bytes[this.position];
+      this.position += 1;
+      const low = BigInt(byte & 127);
+      if (shift === 63n && low > 1n) {
+        throw new Error("digest encoding has a varint above u64");
+      }
+      value |= low << shift;
+      if ((byte & 128) === 0) {
+        if (byte === 0 && shift > 0n) {
+          throw new Error("digest encoding has a varint that is not minimal");
+        }
+        return value;
       }
-      if (Number.isNaN(value) || !Number.isFinite(value)) {
-        this.value = void 0;
+      shift += 7n;
+      if (shift > 63n) {
+        throw new Error("digest encoding has a varint above u64");
+      }
+    }
+  }
+  store() {
+    const len = this.varint();
+    let total = 0n;
+    let previous;
+    for (let i = 0n; i < len; i++) {
+      let index;
+      if (previous === void 0) {
+        const encoded = this.varint();
+        if (encoded > U32_MAX) {
+          throw new Error("digest encoding has a bucket index outside i32");
+        }
+        index = encoded >> 1n ^ -(encoded & 1n);
       } else {
-        if (value !== 0 && Math.abs(value) < _Float4Value.MIN_POSITIVE) {
-          this.value = 0;
-        } else if (value > _Float4Value.MAX_VALUE) {
-          throw new Error(`Float4 overflow: value ${value} exceeds maximum ${_Float4Value.MAX_VALUE}`);
-        } else if (value < _Float4Value.MIN_VALUE) {
-          throw new Error(`Float4 underflow: value ${value} exceeds minimum ${_Float4Value.MIN_VALUE}`);
-        } else {
-          const float32Array = new Float32Array(1);
-          float32Array[0] = value;
-          this.value = float32Array[0];
+        const delta = this.varint();
+        if (delta === 0n) {
+          throw new Error(`digest encoding repeats bucket index ${previous}`);
+        }
+        index = previous + delta;
+        if (index > I32_MAX) {
+          throw new Error("digest encoding has a bucket index outside i32");
         }
       }
+      const count = this.varint();
+      if (count === 0n) {
+        throw new Error(`digest encoding has a zero count at bucket ${index}`);
+      }
+      total += count;
+      previous = index;
+    }
+    return total;
+  }
+};
+
+// src/value/fixed-point.ts
+var FIXED_POINT_MAX_PRECISION = 76;
+var FIXED_POINT_NARROW_PRECISION = 38;
+var DECIMAL_DEFAULT_SCALE = 10;
+function checkPrecision(kind, precision) {
+  if (!Number.isInteger(precision) || precision < 1 || precision > FIXED_POINT_MAX_PRECISION) {
+    throw new Error(`${kind} precision must be a whole number between 1 and ${FIXED_POINT_MAX_PRECISION}, got ${precision}`);
+  }
+}
+function decimalType(precision = FIXED_POINT_MAX_PRECISION, scale = DECIMAL_DEFAULT_SCALE) {
+  checkPrecision("Decimal", precision);
+  if (!Number.isInteger(scale) || scale < 0 || scale > precision) {
+    throw new Error(`Decimal scale must be a whole number between 0 and the precision ${precision}, got ${scale}`);
+  }
+  return { Decimal: { precision, scale } };
+}
+function fixedPointType(kind, precision, scale) {
+  switch (kind) {
+    case "Decimal":
+      return decimalType(precision, scale);
+  }
+}
+function isFixedPointType(t) {
+  return typeof t === "object" && t !== null && "Decimal" in t;
+}
+function fixedPointKind(t) {
+  return "Decimal";
+}
+function fixedPointPrecision(t) {
+  return t.Decimal.precision;
+}
+function fixedPointScale(t) {
+  return "Decimal" in t ? t.Decimal.scale : 0;
+}
+function fixedPointTypeName(t) {
+  const kind = fixedPointKind(t);
+  const precision = fixedPointPrecision(t);
+  if (kind === "Decimal") {
+    const scale = fixedPointScale(t);
+    return precision === FIXED_POINT_MAX_PRECISION && scale === DECIMAL_DEFAULT_SCALE ? kind : `${kind}(${precision}, ${scale})`;
+  }
+  return precision === FIXED_POINT_MAX_PRECISION ? kind : `${kind}(${precision})`;
+}
+
+// src/value/float4.ts
+var _Float4Value = class _Float4Value {
+  constructor(value) {
+    this.type = "Float4";
+    if (value === void 0) {
+      throw new Error(`Float4 value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value !== "number") {
+      throw new Error(`Float4 value must be a number, got ${typeof value}`);
+    }
+    if (Number.isNaN(value) || !Number.isFinite(value)) {
+      throw new Error(`Float4 value must be finite, got ${value}`);
+    }
+    if (value !== 0 && Math.abs(value) < _Float4Value.MIN_POSITIVE) {
+      this.value = 0;
+    } else if (value > _Float4Value.MAX_VALUE) {
+      throw new Error(`Float4 overflow: value ${value} exceeds maximum ${_Float4Value.MAX_VALUE}`);
+    } else if (value < _Float4Value.MIN_VALUE) {
+      throw new Error(`Float4 underflow: value ${value} exceeds minimum ${_Float4Value.MIN_VALUE}`);
     } else {
-      this.value = void 0;
+      const float32Array = new Float32Array(1);
+      float32Array[0] = value;
+      this.value = float32Array[0];
     }
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Float4Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Float4`);
     }
     const num = Number(trimmed);
-    if (Number.isNaN(num) && trimmed.toLowerCase() !== "nan") {
+    if (Number.isNaN(num)) {
       throw new Error(`Cannot parse "${str}" as Float4`);
     }
     return new _Float4Value(num);
@@ -1173,7 +1419,7 @@ var _Float4Value = class _Float4Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Float4 values for equality with limited precision
@@ -1190,12 +1436,12 @@ var _Float4Value = class _Float4Value {
     return Math.abs(this.value - otherFloat.value) <= epsilon;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1208,22 +1454,24 @@ var Float4Value = _Float4Value;
 var Float8Value = class _Float8Value {
   constructor(value) {
     this.type = "Float8";
-    if (value !== void 0) {
-      if (typeof value !== "number") {
-        throw new Error(`Float8 value must be a number, got ${typeof value}`);
-      }
-      this.value = value;
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`Float8 value must be defined, a none is carried by NoneValue`);
     }
+    if (typeof value !== "number") {
+      throw new Error(`Float8 value must be a number, got ${typeof value}`);
+    }
+    if (Number.isNaN(value) || !Number.isFinite(value)) {
+      throw new Error(`Float8 value must be finite, got ${value}`);
+    }
+    this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Float8Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Float8`);
     }
     const num = Number(trimmed);
-    if (Number.isNaN(num) && trimmed.toLowerCase() !== "nan") {
+    if (Number.isNaN(num)) {
       throw new Error(`Cannot parse "${str}" as Float8`);
     }
     return new _Float8Value(num);
@@ -1232,7 +1480,7 @@ var Float8Value = class _Float8Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Float8 values for equality
@@ -1249,12 +1497,12 @@ var Float8Value = class _Float8Value {
     return Math.abs(this.value - otherFloat.value) <= epsilon;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1263,20 +1511,21 @@ var Float8Value = class _Float8Value {
 var _Int1Value = class _Int1Value {
   constructor(value) {
     this.type = "Int1";
-    if (value !== void 0) {
-      if (!Number.isInteger(value)) {
-        throw new Error(`Int1 value must be an integer, got ${value}`);
-      }
-      if (value < _Int1Value.MIN_VALUE || value > _Int1Value.MAX_VALUE) {
-        throw new Error(`Int1 value must be between ${_Int1Value.MIN_VALUE} and ${_Int1Value.MAX_VALUE}, got ${value}`);
-      }
+    if (value === void 0) {
+      throw new Error(`Int1 value must be defined, a none is carried by NoneValue`);
+    }
+    if (!Number.isInteger(value)) {
+      throw new Error(`Int1 value must be an integer, got ${value}`);
+    }
+    if (value < _Int1Value.MIN_VALUE || value > _Int1Value.MAX_VALUE) {
+      throw new Error(`Int1 value must be between ${_Int1Value.MIN_VALUE} and ${_Int1Value.MAX_VALUE}, got ${value}`);
     }
     this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Int1Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Int1`);
     }
     const num = Number(trimmed);
     if (isNaN(num)) {
@@ -1288,7 +1537,7 @@ var _Int1Value = class _Int1Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Int1 values for equality
@@ -1301,12 +1550,12 @@ var _Int1Value = class _Int1Value {
     return this.value === otherInt.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1318,20 +1567,21 @@ var Int1Value = _Int1Value;
 var _Int2Value = class _Int2Value {
   constructor(value) {
     this.type = "Int2";
-    if (value !== void 0) {
-      if (!Number.isInteger(value)) {
-        throw new Error(`Int2 value must be an integer, got ${value}`);
-      }
-      if (value < _Int2Value.MIN_VALUE || value > _Int2Value.MAX_VALUE) {
-        throw new Error(`Int2 value must be between ${_Int2Value.MIN_VALUE} and ${_Int2Value.MAX_VALUE}, got ${value}`);
-      }
+    if (value === void 0) {
+      throw new Error(`Int2 value must be defined, a none is carried by NoneValue`);
+    }
+    if (!Number.isInteger(value)) {
+      throw new Error(`Int2 value must be an integer, got ${value}`);
+    }
+    if (value < _Int2Value.MIN_VALUE || value > _Int2Value.MAX_VALUE) {
+      throw new Error(`Int2 value must be between ${_Int2Value.MIN_VALUE} and ${_Int2Value.MAX_VALUE}, got ${value}`);
     }
     this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Int2Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Int2`);
     }
     const num = Number(trimmed);
     if (isNaN(num)) {
@@ -1343,7 +1593,7 @@ var _Int2Value = class _Int2Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Int2 values for equality
@@ -1356,12 +1606,12 @@ var _Int2Value = class _Int2Value {
     return this.value === otherInt.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1373,20 +1623,21 @@ var Int2Value = _Int2Value;
 var _Int4Value = class _Int4Value {
   constructor(value) {
     this.type = "Int4";
-    if (value !== void 0) {
-      if (!Number.isInteger(value)) {
-        throw new Error(`Int4 value must be an integer, got ${value}`);
-      }
-      if (value < _Int4Value.MIN_VALUE || value > _Int4Value.MAX_VALUE) {
-        throw new Error(`Int4 value must be between ${_Int4Value.MIN_VALUE} and ${_Int4Value.MAX_VALUE}, got ${value}`);
-      }
+    if (value === void 0) {
+      throw new Error(`Int4 value must be defined, a none is carried by NoneValue`);
+    }
+    if (!Number.isInteger(value)) {
+      throw new Error(`Int4 value must be an integer, got ${value}`);
+    }
+    if (value < _Int4Value.MIN_VALUE || value > _Int4Value.MAX_VALUE) {
+      throw new Error(`Int4 value must be between ${_Int4Value.MIN_VALUE} and ${_Int4Value.MAX_VALUE}, got ${value}`);
     }
     this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Int4Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Int4`);
     }
     const num = Number(trimmed);
     if (isNaN(num)) {
@@ -1398,7 +1649,7 @@ var _Int4Value = class _Int4Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Int4 values for equality
@@ -1411,12 +1662,12 @@ var _Int4Value = class _Int4Value {
     return this.value === otherInt.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1428,20 +1679,19 @@ var Int4Value = _Int4Value;
 var _Int8Value = class _Int8Value {
   constructor(value) {
     this.type = "Int8";
-    if (value !== void 0) {
-      const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
-      if (bigintValue < _Int8Value.MIN_VALUE || bigintValue > _Int8Value.MAX_VALUE) {
-        throw new Error(`Int8 value must be between ${_Int8Value.MIN_VALUE} and ${_Int8Value.MAX_VALUE}, got ${bigintValue}`);
-      }
-      this.value = bigintValue;
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`Int8 value must be defined, a none is carried by NoneValue`);
+    }
+    const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
+    if (bigintValue < _Int8Value.MIN_VALUE || bigintValue > _Int8Value.MAX_VALUE) {
+      throw new Error(`Int8 value must be between ${_Int8Value.MIN_VALUE} and ${_Int8Value.MAX_VALUE}, got ${bigintValue}`);
     }
+    this.value = bigintValue;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Int8Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Int8`);
     }
     let value;
     try {
@@ -1458,7 +1708,7 @@ var _Int8Value = class _Int8Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Int8 values for equality
@@ -1471,12 +1721,12 @@ var _Int8Value = class _Int8Value {
     return this.value === otherInt.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1488,31 +1738,30 @@ var Int8Value = _Int8Value;
 var _Int16Value = class _Int16Value {
   constructor(value) {
     this.type = "Int16";
-    if (value !== void 0) {
-      let bigintValue;
-      if (typeof value === "string") {
-        try {
-          bigintValue = BigInt(value);
-        } catch (e) {
-          throw new Error(`Int16 value must be a valid integer, got ${value}`);
-        }
-      } else if (typeof value === "number") {
-        bigintValue = BigInt(Math.trunc(value));
-      } else {
-        bigintValue = value;
-      }
-      if (bigintValue < _Int16Value.MIN_VALUE || bigintValue > _Int16Value.MAX_VALUE) {
-        throw new Error(`Int16 value must be between ${_Int16Value.MIN_VALUE} and ${_Int16Value.MAX_VALUE}, got ${bigintValue}`);
+    if (value === void 0) {
+      throw new Error(`Int16 value must be defined, a none is carried by NoneValue`);
+    }
+    let bigintValue;
+    if (typeof value === "string") {
+      try {
+        bigintValue = BigInt(value);
+      } catch (e) {
+        throw new Error(`Int16 value must be a valid integer, got ${value}`);
       }
-      this.value = bigintValue;
+    } else if (typeof value === "number") {
+      bigintValue = BigInt(Math.trunc(value));
     } else {
-      this.value = void 0;
+      bigintValue = value;
     }
+    if (bigintValue < _Int16Value.MIN_VALUE || bigintValue > _Int16Value.MAX_VALUE) {
+      throw new Error(`Int16 value must be between ${_Int16Value.MIN_VALUE} and ${_Int16Value.MAX_VALUE}, got ${bigintValue}`);
+    }
+    this.value = bigintValue;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Int16Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Int16`);
     }
     let value;
     try {
@@ -1529,7 +1778,7 @@ var _Int16Value = class _Int16Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Int16 values for equality
@@ -1542,12 +1791,12 @@ var _Int16Value = class _Int16Value {
     return this.value === otherInt.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -1560,26 +1809,23 @@ var DurationValue = class _DurationValue {
   // all time components as nanoseconds
   constructor(value) {
     this.type = "Duration";
-    if (value !== void 0) {
-      if (typeof value === "string") {
-        const parsed = _DurationValue.parseDuration(value);
-        if (!parsed) {
-          throw new Error(`Invalid duration string: ${value}`);
-        }
-        this.months = parsed.months;
-        this.days = parsed.days;
-        this.nanos = parsed.nanos;
-      } else if (typeof value === "object" && value !== null) {
-        this.months = value.months;
-        this.days = value.days;
-        this.nanos = value.nanos;
-      } else {
-        throw new Error(`Duration value must be an object or string, got ${typeof value}`);
+    if (value === void 0) {
+      throw new Error(`Duration value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value === "string") {
+      const parsed = _DurationValue.parseDuration(value);
+      if (!parsed) {
+        throw new Error(`Invalid duration string: ${value}`);
       }
+      this.months = parsed.months;
+      this.days = parsed.days;
+      this.nanos = parsed.nanos;
+    } else if (typeof value === "object" && value !== null) {
+      this.months = value.months;
+      this.days = value.days;
+      this.nanos = value.nanos;
     } else {
-      this.months = void 0;
-      this.days = void 0;
-      this.nanos = void 0;
+      throw new Error(`Duration value must be an object or string, got ${typeof value}`);
     }
   }
   /**
@@ -1666,7 +1912,7 @@ var DurationValue = class _DurationValue {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _DurationValue(void 0);
+      throw new Error(`Cannot parse "${str}" as Duration`);
     }
     const parsed = _DurationValue.parseDuration(trimmed);
     if (!parsed) {
@@ -1741,9 +1987,6 @@ var DurationValue = class _DurationValue {
    * Get absolute value of duration
    */
   abs() {
-    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
-      return new _DurationValue(void 0);
-    }
     return new _DurationValue({
       months: Math.abs(this.months),
       days: Math.abs(this.days),
@@ -1754,9 +1997,6 @@ var DurationValue = class _DurationValue {
    * Negate the duration
    */
   negate() {
-    if (this.months === void 0 || this.days === void 0 || this.nanos === void 0) {
-      return new _DurationValue(void 0);
-    }
     return new _DurationValue({
       months: -this.months,
       days: -this.days,
@@ -1952,7 +2192,7 @@ var DurationValue = class _DurationValue {
     return this.months === otherDuration.months && this.days === otherDuration.days && this.nanos === otherDuration.nanos;
   }
   toJSON() {
-    return this.months === void 0 ? null : this.toIsoString();
+    return this.toIsoString();
   }
   encode() {
     return {
@@ -1966,20 +2206,21 @@ var DurationValue = class _DurationValue {
 var _Uint1Value = class _Uint1Value {
   constructor(value) {
     this.type = "Uint1";
-    if (value !== void 0) {
-      if (!Number.isInteger(value)) {
-        throw new Error(`Uint1 value must be an integer, got ${value}`);
-      }
-      if (value < _Uint1Value.MIN_VALUE || value > _Uint1Value.MAX_VALUE) {
-        throw new Error(`Uint1 value must be between ${_Uint1Value.MIN_VALUE} and ${_Uint1Value.MAX_VALUE}, got ${value}`);
-      }
+    if (value === void 0) {
+      throw new Error(`Uint1 value must be defined, a none is carried by NoneValue`);
+    }
+    if (!Number.isInteger(value)) {
+      throw new Error(`Uint1 value must be an integer, got ${value}`);
+    }
+    if (value < _Uint1Value.MIN_VALUE || value > _Uint1Value.MAX_VALUE) {
+      throw new Error(`Uint1 value must be between ${_Uint1Value.MIN_VALUE} and ${_Uint1Value.MAX_VALUE}, got ${value}`);
     }
     this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uint1Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uint1`);
     }
     const num = Number(trimmed);
     if (isNaN(num)) {
@@ -1991,7 +2232,7 @@ var _Uint1Value = class _Uint1Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Uint1 values for equality
@@ -2004,12 +2245,12 @@ var _Uint1Value = class _Uint1Value {
     return this.value === otherUint.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2021,20 +2262,21 @@ var Uint1Value = _Uint1Value;
 var _Uint2Value = class _Uint2Value {
   constructor(value) {
     this.type = "Uint2";
-    if (value !== void 0) {
-      if (!Number.isInteger(value)) {
-        throw new Error(`Uint2 value must be an integer, got ${value}`);
-      }
-      if (value < _Uint2Value.MIN_VALUE || value > _Uint2Value.MAX_VALUE) {
-        throw new Error(`Uint2 value must be between ${_Uint2Value.MIN_VALUE} and ${_Uint2Value.MAX_VALUE}, got ${value}`);
-      }
+    if (value === void 0) {
+      throw new Error(`Uint2 value must be defined, a none is carried by NoneValue`);
+    }
+    if (!Number.isInteger(value)) {
+      throw new Error(`Uint2 value must be an integer, got ${value}`);
+    }
+    if (value < _Uint2Value.MIN_VALUE || value > _Uint2Value.MAX_VALUE) {
+      throw new Error(`Uint2 value must be between ${_Uint2Value.MIN_VALUE} and ${_Uint2Value.MAX_VALUE}, got ${value}`);
     }
     this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uint2Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uint2`);
     }
     const num = Number(trimmed);
     if (isNaN(num)) {
@@ -2046,7 +2288,7 @@ var _Uint2Value = class _Uint2Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Uint2 values for equality
@@ -2059,12 +2301,12 @@ var _Uint2Value = class _Uint2Value {
     return this.value === otherUint.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2076,20 +2318,21 @@ var Uint2Value = _Uint2Value;
 var _Uint4Value = class _Uint4Value {
   constructor(value) {
     this.type = "Uint4";
-    if (value !== void 0) {
-      if (!Number.isInteger(value)) {
-        throw new Error(`Uint4 value must be an integer, got ${value}`);
-      }
-      if (value < _Uint4Value.MIN_VALUE || value > _Uint4Value.MAX_VALUE) {
-        throw new Error(`Uint4 value must be between ${_Uint4Value.MIN_VALUE} and ${_Uint4Value.MAX_VALUE}, got ${value}`);
-      }
+    if (value === void 0) {
+      throw new Error(`Uint4 value must be defined, a none is carried by NoneValue`);
+    }
+    if (!Number.isInteger(value)) {
+      throw new Error(`Uint4 value must be an integer, got ${value}`);
+    }
+    if (value < _Uint4Value.MIN_VALUE || value > _Uint4Value.MAX_VALUE) {
+      throw new Error(`Uint4 value must be between ${_Uint4Value.MIN_VALUE} and ${_Uint4Value.MAX_VALUE}, got ${value}`);
     }
     this.value = value;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uint4Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uint4`);
     }
     const num = Number(trimmed);
     if (isNaN(num)) {
@@ -2101,7 +2344,7 @@ var _Uint4Value = class _Uint4Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Uint4 values for equality
@@ -2114,12 +2357,12 @@ var _Uint4Value = class _Uint4Value {
     return this.value === otherUint.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2131,20 +2374,19 @@ var Uint4Value = _Uint4Value;
 var _Uint8Value = class _Uint8Value {
   constructor(value) {
     this.type = "Uint8";
-    if (value !== void 0) {
-      const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
-      if (bigintValue < _Uint8Value.MIN_VALUE || bigintValue > _Uint8Value.MAX_VALUE) {
-        throw new Error(`Uint8 value must be between ${_Uint8Value.MIN_VALUE} and ${_Uint8Value.MAX_VALUE}, got ${bigintValue}`);
-      }
-      this.value = bigintValue;
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`Uint8 value must be defined, a none is carried by NoneValue`);
+    }
+    const bigintValue = typeof value === "number" ? BigInt(Math.trunc(value)) : value;
+    if (bigintValue < _Uint8Value.MIN_VALUE || bigintValue > _Uint8Value.MAX_VALUE) {
+      throw new Error(`Uint8 value must be between ${_Uint8Value.MIN_VALUE} and ${_Uint8Value.MAX_VALUE}, got ${bigintValue}`);
     }
+    this.value = bigintValue;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uint8Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uint8`);
     }
     let value;
     try {
@@ -2165,7 +2407,7 @@ var _Uint8Value = class _Uint8Value {
     return Number(this.value);
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Uint8 values for equality
@@ -2178,12 +2420,12 @@ var _Uint8Value = class _Uint8Value {
     return this.value === otherUint.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2195,31 +2437,30 @@ var Uint8Value = _Uint8Value;
 var _Uint16Value = class _Uint16Value {
   constructor(value) {
     this.type = "Uint16";
-    if (value !== void 0) {
-      let bigintValue;
-      if (typeof value === "string") {
-        try {
-          bigintValue = BigInt(value);
-        } catch (e) {
-          throw new Error(`Uint16 value must be a valid integer, got ${value}`);
-        }
-      } else if (typeof value === "number") {
-        bigintValue = BigInt(Math.trunc(value));
-      } else {
-        bigintValue = value;
-      }
-      if (bigintValue < _Uint16Value.MIN_VALUE || bigintValue > _Uint16Value.MAX_VALUE) {
-        throw new Error(`Uint16 value must be between ${_Uint16Value.MIN_VALUE} and ${_Uint16Value.MAX_VALUE}, got ${bigintValue}`);
+    if (value === void 0) {
+      throw new Error(`Uint16 value must be defined, a none is carried by NoneValue`);
+    }
+    let bigintValue;
+    if (typeof value === "string") {
+      try {
+        bigintValue = BigInt(value);
+      } catch (e) {
+        throw new Error(`Uint16 value must be a valid integer, got ${value}`);
       }
-      this.value = bigintValue;
+    } else if (typeof value === "number") {
+      bigintValue = BigInt(Math.trunc(value));
     } else {
-      this.value = void 0;
+      bigintValue = value;
+    }
+    if (bigintValue < _Uint16Value.MIN_VALUE || bigintValue > _Uint16Value.MAX_VALUE) {
+      throw new Error(`Uint16 value must be between ${_Uint16Value.MIN_VALUE} and ${_Uint16Value.MAX_VALUE}, got ${bigintValue}`);
     }
+    this.value = bigintValue;
   }
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uint16Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uint16`);
     }
     let value;
     try {
@@ -2236,7 +2477,7 @@ var _Uint16Value = class _Uint16Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value.toString();
+    return this.value.toString();
   }
   /**
    * Compare two Uint16 values for equality
@@ -2249,12 +2490,12 @@ var _Uint16Value = class _Uint16Value {
     return this.value === otherUint.value;
   }
   toJSON() {
-    return this.value === void 0 ? null : this.value.toString();
+    return this.value.toString();
   }
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2383,7 +2624,22 @@ function formatValue(value) {
 
 // src/value/option.ts
 function describeType(t) {
-  return isOptionType(t) ? `Option(${describeType(t.Option)})` : t;
+  if (isDigestType(t)) {
+    return digestTypeName(t);
+  }
+  if (isFixedPointType(t)) {
+    return fixedPointTypeName(t);
+  }
+  if (isOptionType(t)) {
+    return `Option(${describeType(t.Option)})`;
+  }
+  if (isListType(t)) {
+    return `List(${describeType(t.List)})`;
+  }
+  if (isRecordType(t)) {
+    return `Record(${t.Record.map((field) => `${field.name}: ${describeType(field.type)}`).join(", ")})`;
+  }
+  return t;
 }
 function hasType(value) {
   return typeof value === "object" && value !== null && "type" in value;
@@ -2451,18 +2707,17 @@ var Option = _Option;
 var Utf8Value = class _Utf8Value {
   constructor(value) {
     this.type = "Utf8";
-    if (value !== void 0) {
-      if (typeof value !== "string") {
-        throw new Error(`Utf8 value must be a string, got ${typeof value}`);
-      }
-      this.value = value;
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`Utf8 value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value !== "string") {
+      throw new Error(`Utf8 value must be a string, got ${typeof value}`);
     }
+    this.value = value;
   }
   static parse(str) {
     if (str === NONE_VALUE) {
-      return new _Utf8Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Utf8`);
     }
     return new _Utf8Value(str);
   }
@@ -2470,7 +2725,7 @@ var Utf8Value = class _Utf8Value {
     return this.value;
   }
   toString() {
-    return this.value === void 0 ? "none" : this.value;
+    return this.value;
   }
   /**
    * Compare two Utf8 values for equality
@@ -2488,7 +2743,7 @@ var Utf8Value = class _Utf8Value {
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2498,21 +2753,20 @@ import { v4 as uuidv4, NIL as NIL_UUID, validate, version } from "uuid";
 var Uuid4Value = class _Uuid4Value {
   constructor(value) {
     this.type = "Uuid4";
-    if (value !== void 0) {
-      if (typeof value !== "string") {
-        throw new Error(`Uuid4 value must be a string, got ${typeof value}`);
-      }
-      if (!validate(value)) {
-        throw new Error(`Invalid UUID format: ${value}`);
-      }
-      const ver = version(value);
-      if (value !== NIL_UUID && ver !== 4) {
-        throw new Error(`Invalid UUID version for Uuid4: expected v4, got v${ver}`);
-      }
-      this.uuid = value.toLowerCase();
-    } else {
-      this.uuid = void 0;
+    if (value === void 0) {
+      throw new Error(`Uuid4 value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value !== "string") {
+      throw new Error(`Uuid4 value must be a string, got ${typeof value}`);
+    }
+    if (!validate(value)) {
+      throw new Error(`Invalid UUID format: ${value}`);
+    }
+    const ver = version(value);
+    if (value !== NIL_UUID && ver !== 4) {
+      throw new Error(`Invalid UUID version for Uuid4: expected v4, got v${ver}`);
     }
+    this.uuid = value.toLowerCase();
   }
   /**
    * Generate a new random UUID v4
@@ -2544,7 +2798,7 @@ var Uuid4Value = class _Uuid4Value {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uuid4Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uuid4`);
     }
     if (!validate(trimmed)) {
       throw new Error(`Cannot parse "${str}" as Uuid4`);
@@ -2566,10 +2820,10 @@ var Uuid4Value = class _Uuid4Value {
    */
   asBytes() {
     if (this.uuid === void 0) return void 0;
-    const hex = this.uuid.replace(/-/g, "");
+    const hex2 = this.uuid.replace(/-/g, "");
     const bytes = new Uint8Array(16);
     for (let i = 0; i < 16; i++) {
-      bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+      bytes[i] = parseInt(hex2.substring(i * 2, i * 2 + 2), 16);
     }
     return bytes;
   }
@@ -2637,7 +2891,7 @@ var Uuid4Value = class _Uuid4Value {
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2647,21 +2901,20 @@ import { v7 as uuidv7, NIL as NIL_UUID2, validate as validate2, version as versi
 var Uuid7Value = class _Uuid7Value {
   constructor(value) {
     this.type = "Uuid7";
-    if (value !== void 0) {
-      if (typeof value !== "string") {
-        throw new Error(`Uuid7 value must be a string, got ${typeof value}`);
-      }
-      if (!validate2(value)) {
-        throw new Error(`Invalid UUID format: ${value}`);
-      }
-      const ver = version2(value);
-      if (value !== NIL_UUID2 && ver !== 7) {
-        throw new Error(`Invalid UUID version for Uuid7: expected v7, got v${ver}`);
-      }
-      this.uuid = value.toLowerCase();
-    } else {
-      this.uuid = void 0;
+    if (value === void 0) {
+      throw new Error(`Uuid7 value must be defined, a none is carried by NoneValue`);
     }
+    if (typeof value !== "string") {
+      throw new Error(`Uuid7 value must be a string, got ${typeof value}`);
+    }
+    if (!validate2(value)) {
+      throw new Error(`Invalid UUID format: ${value}`);
+    }
+    const ver = version2(value);
+    if (value !== NIL_UUID2 && ver !== 7) {
+      throw new Error(`Invalid UUID version for Uuid7: expected v7, got v${ver}`);
+    }
+    this.uuid = value.toLowerCase();
   }
   /**
    * Generate a new timestamp-based UUID v7
@@ -2693,7 +2946,7 @@ var Uuid7Value = class _Uuid7Value {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _Uuid7Value(void 0);
+      throw new Error(`Cannot parse "${str}" as Uuid7`);
     }
     if (!validate2(trimmed)) {
       throw new Error(`Cannot parse "${str}" as Uuid7`);
@@ -2715,10 +2968,10 @@ var Uuid7Value = class _Uuid7Value {
    */
   asBytes() {
     if (this.uuid === void 0) return void 0;
-    const hex = this.uuid.replace(/-/g, "");
+    const hex2 = this.uuid.replace(/-/g, "");
     const bytes = new Uint8Array(16);
     for (let i = 0; i < 16; i++) {
-      bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+      bytes[i] = parseInt(hex2.substring(i * 2, i * 2 + 2), 16);
     }
     return bytes;
   }
@@ -2727,8 +2980,8 @@ var Uuid7Value = class _Uuid7Value {
    */
   getTimestamp() {
     if (this.uuid === void 0 || this.uuid === NIL_UUID2) return void 0;
-    const hex = this.uuid.replace(/-/g, "");
-    const timestampHex = hex.substring(0, 12);
+    const hex2 = this.uuid.replace(/-/g, "");
+    const timestampHex = hex2.substring(0, 12);
     const timestamp = parseInt(timestampHex, 16);
     return timestamp;
   }
@@ -2797,7 +3050,7 @@ var Uuid7Value = class _Uuid7Value {
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
     };
   }
 };
@@ -2807,21 +3060,20 @@ import { v7 as uuidv72, NIL as NIL_UUID3, validate as validate3, version as vers
 var IdentityIdValue = class _IdentityIdValue {
   constructor(value) {
     this.type = "IdentityId";
-    if (value !== void 0) {
-      if (typeof value !== "string") {
-        throw new Error(`IdentityId value must be a string, got ${typeof value}`);
-      }
-      if (!validate3(value)) {
-        throw new Error(`Invalid UUID format for IdentityId: ${value}`);
-      }
-      const ver = version3(value);
-      if (value !== NIL_UUID3 && ver !== 7) {
-        throw new Error(`Invalid UUID version for IdentityId: expected v7, got v${ver}`);
-      }
-      this.value = value.toLowerCase();
-    } else {
-      this.value = void 0;
+    if (value === void 0) {
+      throw new Error(`IdentityId value must be defined, a none is carried by NoneValue`);
+    }
+    if (typeof value !== "string") {
+      throw new Error(`IdentityId value must be a string, got ${typeof value}`);
+    }
+    if (!validate3(value)) {
+      throw new Error(`Invalid UUID format for IdentityId: ${value}`);
     }
+    const ver = version3(value);
+    if (value !== NIL_UUID3 && ver !== 7) {
+      throw new Error(`Invalid UUID version for IdentityId: expected v7, got v${ver}`);
+    }
+    this.value = value.toLowerCase();
   }
   /**
    * Generate a new IdentityId with a UUID v7
@@ -2841,7 +3093,7 @@ var IdentityIdValue = class _IdentityIdValue {
   static parse(str) {
     const trimmed = str.trim();
     if (trimmed === "" || trimmed === NONE_VALUE) {
-      return new _IdentityIdValue(void 0);
+      throw new Error(`Cannot parse "${str}" as IdentityId`);
     }
     if (!validate3(trimmed)) {
       throw new Error(`Cannot parse "${str}" as IdentityId`);
@@ -2862,15 +3114,15 @@ var IdentityIdValue = class _IdentityIdValue {
    * Format as string
    */
   toString() {
-    return this.value === void 0 ? "none" : this.value;
+    return this.value;
   }
   /**
    * Extract the timestamp from the UUID v7 (milliseconds since Unix epoch)
    */
   getTimestamp() {
     if (this.value === void 0 || this.value === NIL_UUID3) return void 0;
-    const hex = this.value.replace(/-/g, "");
-    const timestampHex = hex.substring(0, 12);
+    const hex2 = this.value.replace(/-/g, "");
+    const timestampHex = hex2.substring(0, 12);
     const timestamp = parseInt(timestampHex, 16);
     return timestamp;
   }
@@ -2896,58 +3148,235 @@ var IdentityIdValue = class _IdentityIdValue {
   encode() {
     return {
       type: this.type,
-      value: this.value === void 0 ? NONE_VALUE : this.toString()
+      value: this.toString()
+    };
+  }
+};
+
+// src/value/list.ts
+function hasToJSON2(value) {
+  return typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function";
+}
+var ListValue = class _ListValue {
+  constructor(items, elementType) {
+    if (!Array.isArray(items)) {
+      throw new Error(`List value must be an array, got ${typeof items}`);
+    }
+    if (items.length === 0 && elementType === void 0) {
+      throw new Error("An empty List has no element type to infer, pass it explicitly: new ListValue([], elementType)");
+    }
+    this.items = items;
+    this.elementType = elementType;
+  }
+  get type() {
+    return { List: this.elementType ?? this.items[0].type };
+  }
+  equals(other) {
+    if (!(other instanceof _ListValue) || this.items.length !== other.items.length) {
+      return false;
+    }
+    return this.items.every((item, i) => item.equals(other.items[i]));
+  }
+  toString() {
+    return `[${this.items.map((item) => item.toString()).join(", ")}]`;
+  }
+  toJSON() {
+    return this.items.map((item) => hasToJSON2(item) ? item.toJSON() : item);
+  }
+  encode() {
+    const elementType = this.elementType ?? this.items[0].type;
+    return {
+      type: { List: elementType },
+      value: this.items.map((item) => item.encode().value)
     };
   }
 };
 
+// src/value/record.ts
+function hasToJSON3(value) {
+  return typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function";
+}
+var RecordValue = class _RecordValue {
+  constructor(fields) {
+    if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
+      throw new Error(`Record value must be a plain object of fields, got ${typeof fields}`);
+    }
+    this.fields = fields;
+  }
+  get type() {
+    return { Record: Object.entries(this.fields).map(([name, value]) => ({ name, type: value.encode().type })) };
+  }
+  equals(other) {
+    if (!(other instanceof _RecordValue)) {
+      return false;
+    }
+    const names = Object.keys(this.fields);
+    const otherNames = Object.keys(other.fields);
+    if (names.length !== otherNames.length || names.some((name, i) => name !== otherNames[i])) {
+      return false;
+    }
+    return names.every((name) => this.fields[name].equals(other.fields[name]));
+  }
+  toString() {
+    return `{${Object.entries(this.fields).map(([name, value]) => `${name}: ${value.toString()}`).join(", ")}}`;
+  }
+  toJSON() {
+    return Object.fromEntries(Object.entries(this.fields).map(([name, value]) => [name, hasToJSON3(value) ? value.toJSON() : value]));
+  }
+  encode() {
+    const fields = this.type.Record;
+    const value = {};
+    for (const [name, field] of Object.entries(this.fields)) {
+      value[name] = field.encode().value;
+    }
+    return { type: { Record: fields }, value };
+  }
+};
+
 // src/value/wire-type.ts
+function peelOption(type) {
+  return isOptionType(type) ? peelOption(type.Option) : type;
+}
 function typeToWire(type) {
-  return isOptionType(type) ? { id: "Option", underlying: typeToWire(type.Option) } : { id: type };
+  if (isOptionType(type)) {
+    return { id: "Option", underlying: typeToWire(type.Option) };
+  }
+  if (isDigestType(type)) {
+    return { id: "Digest", underlying: { id: type.Digest.inner }, accuracy: type.Digest.accuracy };
+  }
+  if (isFixedPointType(type)) {
+    const kind = fixedPointKind(type);
+    const wire = { id: kind, precision: fixedPointPrecision(type) };
+    if (kind === "Decimal") wire.scale = fixedPointScale(type);
+    return wire;
+  }
+  if (isListType(type)) {
+    return { id: "List", underlying: typeToWire(type.List) };
+  }
+  if (isRecordType(type)) {
+    return { id: "Record", underlying: type.Record.map((field) => ({ name: field.name, type: typeToWire(field.type) })) };
+  }
+  return { id: type };
 }
 function typeFromWire(wire) {
   if (!wire || typeof wire !== "object" || typeof wire.id !== "string") {
     throw new Error(`Expected a type descriptor object, got ${JSON.stringify(wire)}`);
   }
   if (wire.id === "Option") {
-    if (!wire.underlying) {
+    if (!wire.underlying || Array.isArray(wire.underlying)) {
       throw new Error("Option type descriptor is missing its underlying type");
     }
     return { Option: typeFromWire(wire.underlying) };
   }
+  if (wire.id === "Digest") {
+    const inner = !Array.isArray(wire.underlying) ? wire.underlying?.id : void 0;
+    if (typeof inner !== "string" || typeof wire.accuracy !== "number") {
+      throw new Error(`Digest type descriptor needs an underlying type and a numeric accuracy, got ${JSON.stringify(wire)}`);
+    }
+    return digestType(inner, wire.accuracy);
+  }
+  if (wire.id === "Decimal") {
+    const precision = wire.precision ?? FIXED_POINT_MAX_PRECISION;
+    return decimalType(precision, wire.scale ?? DECIMAL_DEFAULT_SCALE);
+  }
+  if (wire.id === "List") {
+    if (!wire.underlying || Array.isArray(wire.underlying)) {
+      throw new Error("List type descriptor is missing its underlying type");
+    }
+    return { List: typeFromWire(wire.underlying) };
+  }
+  if (wire.id === "Record") {
+    if (!Array.isArray(wire.underlying)) {
+      throw new Error("Record type descriptor needs an underlying array of fields");
+    }
+    return { Record: wire.underlying.map((field) => ({ name: field.name, type: typeFromWire(field.type) })) };
+  }
   return wire.id;
 }
 function columnsFromWire(columns) {
   return columns.map((column) => ({ ...column, type: typeFromWire(column.type) }));
 }
+var LEGACY_FRAME_KEYS = ["row_numbers", "created_at", "updated_at", "time"];
 function framesFromWire(frames) {
-  return frames.map(
-    (frame) => frame && frame.columns ? { ...frame, columns: columnsFromWire(frame.columns) } : frame
-  );
+  return frames.map((frame) => {
+    for (const key of LEGACY_FRAME_KEYS) {
+      if (Array.isArray(frame?.[key]) && frame[key].length > 0) {
+        throw new Error(`frame key ${key} is not supported, system columns travel as # columns`);
+      }
+    }
+    return frame && frame.columns ? { ...frame, columns: columnsFromWire(frame.columns) } : frame;
+  });
 }
 function envelopeToColumns(envelope) {
-  const types = envelope?.types ?? {};
+  const types = envelope?.types;
   const rows = envelope?.rows ?? [];
-  return Object.keys(types).map((name) => ({
-    name,
-    type: typeFromWire(types[name]),
-    payload: rows.map((row) => payloadOf(row?.[name]))
-  }));
+  if (!types || typeof types !== "object") {
+    if (rows.length > 0) {
+      throw new Error(`Frame envelope carries rows but no column types, got ${JSON.stringify(envelope)}`);
+    }
+    return [];
+  }
+  return Object.keys(types).map((name) => {
+    const type = typeFromWire(types[name]);
+    return {
+      name,
+      type,
+      payload: rows.map((row) => payloadOf(row, name, type))
+    };
+  });
 }
 function envelopesToFrames(envelopes) {
-  return Array.isArray(envelopes) ? envelopes.map((envelope) => ({ columns: envelopeToColumns(envelope) })) : [];
+  if (!Array.isArray(envelopes)) {
+    throw new Error(`Expected a list of frame envelopes, got ${JSON.stringify(envelopes)}`);
+  }
+  return envelopes.map((envelope) => {
+    const rows = envelope?.rows ?? [];
+    return {
+      columns: envelopeToColumns(envelope),
+      row_numbers: rows.length > 0 && ROW_NUMBER_KEY in rows[0] ? rows.map((row) => row[ROW_NUMBER_KEY]) : void 0
+    };
+  });
 }
-function payloadOf(value) {
+function payloadOf(row, name, type) {
+  if (!row || typeof row !== "object" || !(name in row)) {
+    throw new Error(`Row is missing a cell for column ${name}`);
+  }
+  const value = row[name];
   if (value === null || value === void 0) {
+    if (!isOptionType(type)) {
+      throw new Error(`A none cell cannot fit the non-option column ${name}`);
+    }
     return NONE_VALUE;
   }
-  return typeof value === "string" ? value : String(value);
+  const base = peelOption(type);
+  if (isListType(base) || isRecordType(base)) {
+    return value;
+  }
+  if (base === "Boolean") {
+    if (typeof value !== "boolean") {
+      throw new Error(`Cell for column ${name} must arrive as a boolean, got ${typeof value}`);
+    }
+    return value;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Cell for column ${name} must arrive as text, got ${typeof value}`);
+  }
+  return value;
 }
 
 // src/value/index.ts
 function isOptionType(t) {
   return typeof t === "object" && t !== null && "Option" in t;
 }
+function isDigestType(t) {
+  return typeof t === "object" && t !== null && "Digest" in t;
+}
+function isListType(t) {
+  return typeof t === "object" && t !== null && "List" in t;
+}
+function isRecordType(t) {
+  return typeof t === "object" && t !== null && "Record" in t;
+}
 function unwrapOptionType(t) {
   if (isOptionType(t)) return unwrapOptionType(t.Option);
   return t;
@@ -2967,7 +3396,7 @@ function stripOptionLayers(type, layers) {
 }
 function decode(pair) {
   if (isOptionType(pair.type)) {
-    const noneAt = noneMarkerDepth(pair.value);
+    const noneAt = typeof pair.value === "string" ? noneMarkerDepth(pair.value) : void 0;
     if (noneAt === void 0) {
       return decode({ type: unwrapOptionType(pair.type), value: pair.value });
     }
@@ -2977,65 +3406,127 @@ function decode(pair) {
     }
     return new NoneValue(stripOptionLayers(pair.type, noneAt + 1));
   }
+  if (isDigestType(pair.type)) {
+    return DigestValue.parse(pair.value, pair.type);
+  }
+  if (isFixedPointType(pair.type)) {
+    if (typeof pair.value !== "string") {
+      throw new Error(`Cell for type ${fixedPointTypeName(pair.type)} must be a JSON string, got ${typeof pair.value}`);
+    }
+    return DecimalValue.parse(pair.value);
+  }
+  if (isListType(pair.type)) {
+    if (!Array.isArray(pair.value)) {
+      throw new Error(`List value must be a JSON array, got ${typeof pair.value}`);
+    }
+    const elementType = pair.type.List;
+    return new ListValue(pair.value.map((item) => decode({ type: elementType, value: item })), elementType);
+  }
+  if (isRecordType(pair.type)) {
+    if (typeof pair.value !== "object" || pair.value === null || Array.isArray(pair.value)) {
+      throw new Error(`Record value must be a JSON object, got ${typeof pair.value}`);
+    }
+    const obj = pair.value;
+    const fields = {};
+    for (const field of pair.type.Record) {
+      if (!(field.name in obj)) {
+        throw new Error(`record is missing field '${field.name}'`);
+      }
+      fields[field.name] = decode({ type: field.type, value: obj[field.name] });
+    }
+    return new RecordValue(fields);
+  }
+  if (pair.type === "Boolean" && typeof pair.value === "boolean") {
+    return new BooleanValue(pair.value);
+  }
+  if (typeof pair.value !== "string") {
+    throw new Error(`Cell for type ${pair.type} must be a JSON string, got ${typeof pair.value}`);
+  }
+  const value = pair.value;
   switch (pair.type) {
     case "Blob":
-      return BlobValue.parse(pair.value);
+      return BlobValue.parse(value);
     case "Boolean":
-      return BooleanValue.parse(pair.value);
+      return BooleanValue.parse(value);
     case "Date":
-      return DateValue.parse(pair.value);
+      return DateValue.parse(value);
     case "DateTime":
-      return DateTimeValue.parse(pair.value);
+      return DateTimeValue.parse(value);
     case "Decimal":
-      return DecimalValue.parse(pair.value);
+      return DecimalValue.parse(value);
     case "Float4":
-      return Float4Value.parse(pair.value);
+      return Float4Value.parse(value);
     case "Float8":
-      return Float8Value.parse(pair.value);
+      return Float8Value.parse(value);
     case "Int1":
-      return Int1Value.parse(pair.value);
+      return Int1Value.parse(value);
     case "Int2":
-      return Int2Value.parse(pair.value);
+      return Int2Value.parse(value);
     case "Int4":
-      return Int4Value.parse(pair.value);
+      return Int4Value.parse(value);
     case "Int8":
-      return Int8Value.parse(pair.value);
+      return Int8Value.parse(value);
     case "Int16":
-      return Int16Value.parse(pair.value);
+      return Int16Value.parse(value);
     case "Duration":
-      return DurationValue.parse(pair.value);
+      return DurationValue.parse(value);
     case "Time":
-      return TimeValue.parse(pair.value);
+      return TimeValue.parse(value);
     case "Uint1":
-      return Uint1Value.parse(pair.value);
+      return Uint1Value.parse(value);
     case "Uint2":
-      return Uint2Value.parse(pair.value);
+      return Uint2Value.parse(value);
     case "Uint4":
-      return Uint4Value.parse(pair.value);
+      return Uint4Value.parse(value);
     case "Uint8":
-      return Uint8Value.parse(pair.value);
+      return Uint8Value.parse(value);
     case "Uint16":
-      return Uint16Value.parse(pair.value);
+      return Uint16Value.parse(value);
     case "None":
-      return NoneValue.parse(pair.value);
+      return NoneValue.parse(value);
     case "Utf8":
-      return Utf8Value.parse(pair.value);
+      return Utf8Value.parse(value);
     case "Uuid4":
-      return Uuid4Value.parse(pair.value);
+      return Uuid4Value.parse(value);
     case "Uuid7":
-      return Uuid7Value.parse(pair.value);
+      return Uuid7Value.parse(value);
     case "IdentityId":
-      return IdentityIdValue.parse(pair.value);
+      return IdentityIdValue.parse(value);
     default:
       throw new Error(`Unsupported type: ${pair.type}`);
   }
 }
-function columnsToRows(columns) {
+function rowNumberOf(cell) {
+  const rowNumber = Number(cell);
+  if (!Number.isFinite(rowNumber)) {
+    throw new Error(`row number ${JSON.stringify(cell)} is not a number`);
+  }
+  return rowNumber;
+}
+function columnsToRows(columns, rowNumbers) {
   const rowCount = columns[0]?.payload.length ?? 0;
+  for (const column of columns) {
+    if (column.payload.length !== rowCount) {
+      throw new Error(
+        `column ${column.name} carries ${column.payload.length} cells where ${columns[0].name} carries ${rowCount}`
+      );
+    }
+  }
+  const hasRowNumbers = rowNumbers !== void 0 && rowNumbers.length > 0;
+  if (hasRowNumbers && rowNumbers.length !== rowCount) {
+    throw new Error(`row numbers cover ${rowNumbers.length} of ${rowCount} rows`);
+  }
   return Array.from({ length: rowCount }, (_, i) => {
     const row = {};
     for (const col of columns) {
-      row[col.name] = decode({ type: col.type, value: col.payload[i] });
+      if (col.name === ROW_NUMBER_KEY) {
+        row[ROW_NUMBER_KEY] = rowNumberOf(col.payload[i]);
+      } else {
+        row[col.name] = decode({ type: col.type, value: col.payload[i] });
+      }
+    }
+    if (hasRowNumbers) {
+      row[ROW_NUMBER_KEY] = Number(rowNumbers[i]);
     }
     return row;
   });
@@ -3054,7 +3545,7 @@ function encodeValue(value, name = "$1") {
       return { type: value.type, value: NONE_VALUE };
     }
     const inner = encodeValue(value.unwrap(), name);
-    const noneAt = noneMarkerDepth(inner.value);
+    const noneAt = typeof inner.value === "string" ? noneMarkerDepth(inner.value) : void 0;
     return {
       type: { Option: inner.type },
       value: noneAt === void 0 ? inner.value : noneMarker(noneAt + 1)
@@ -3063,6 +3554,16 @@ function encodeValue(value, name = "$1") {
   if (value && typeof value === "object" && "encode" in value && typeof value.encode === "function") {
     return value.encode();
   }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error(`parameter ${name} is an empty array with no element type to infer, use new ListValue([], elementType)`);
+    }
+    const items = value.map((item, i) => encodeValue(item, `${name}[${i}]`));
+    return {
+      type: { List: items[0].type },
+      value: items.map((item) => item.value)
+    };
+  }
   if (typeof value === "boolean") {
     return { type: "Boolean", value: value.toString() };
   }
@@ -3117,13 +3618,27 @@ function encodeValue(value, name = "$1") {
     return { type: "DateTime", value: value.toISOString() };
   }
   if (value instanceof Uint8Array) {
-    const hex = Array.from(value).map((b) => b.toString(16).padStart(2, "0")).join("");
-    return { type: "Blob", value: "0x" + hex };
+    const hex2 = Array.from(value).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { type: "Blob", value: "0x" + hex2 };
   }
   if (value instanceof ArrayBuffer) {
     const uint8Array = new Uint8Array(value);
-    const hex = Array.from(uint8Array).map((b) => b.toString(16).padStart(2, "0")).join("");
-    return { type: "Blob", value: "0x" + hex };
+    const hex2 = Array.from(uint8Array).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { type: "Blob", value: "0x" + hex2 };
+  }
+  if (typeof value === "object" && value.constructor === Object) {
+    const rawEntries = Object.entries(value);
+    if (rawEntries.length > 0 && rawEntries.every(([, v]) => typeof v !== "function")) {
+      const entries = rawEntries.map(([key, v]) => [key, encodeValue(v, `${name}.${key}`)]);
+      const fields = {};
+      for (const [key, pair] of entries) {
+        fields[key] = pair.value;
+      }
+      return {
+        type: { Record: entries.map(([key, pair]) => ({ name: key, type: pair.type })) },
+        value: fields
+      };
+    }
   }
   throw new Error(`Cannot encode value of type ${typeof value}: ${value}`);
 }
@@ -3146,50 +3661,6 @@ function encodeParams(params) {
   throw new Error(`Invalid parameters type: expected array or object, got ${typeof params}`);
 }
 
-// src/type-code.ts
-var TYPE_CODE = {
-  None: 0,
-  Boolean: 1,
-  Float4: 2,
-  Float8: 3,
-  Int1: 4,
-  Int2: 5,
-  Int4: 6,
-  Int8: 7,
-  Int16: 8,
-  Utf8: 9,
-  Uint1: 10,
-  Uint2: 11,
-  Uint4: 12,
-  Uint8: 13,
-  Uint16: 14,
-  Date: 15,
-  DateTime: 16,
-  Time: 17,
-  Duration: 18,
-  IdentityId: 19,
-  Uuid4: 20,
-  Uuid7: 21,
-  Blob: 22,
-  Int: 23,
-  Uint: 24,
-  Decimal: 25,
-  Any: 26,
-  DictionaryId: 27,
-  Type: 28,
-  List: 29,
-  Record: 30,
-  Tuple: 31
-};
-var CODE_TO_NAME = Object.fromEntries(
-  Object.entries(TYPE_CODE).map(([k, v]) => [v, k])
-);
-function typeNameFromCode(code) {
-  const name = CODE_TO_NAME[code];
-  if (!name) throw new Error(`Unknown type code: ${code}`);
-  return name;
-}
-
 // src/shape/builder.ts
 var ShapeBuilder = class {
   static blob() {
@@ -3561,7 +4032,7 @@ var NUMERIC = {
   Float8: { kind: "float", bits: 64 }
 };
 function widens(target, actual) {
-  if (isOptionType(actual)) {
+  if (typeof actual !== "string") {
     return false;
   }
   const t = NUMERIC[target];
@@ -3635,12 +4106,18 @@ function familyOf(type) {
   return FAMILIES.find((family) => family.includes(type)) ?? [type];
 }
 function matches(shape, type) {
+  if (isFixedPointType(type)) {
+    const kind = fixedPointKind(type);
+    if (shape.kind === "primitive") return familyOf(shape.type).includes(kind);
+    if (shape.kind === "value") return shape.type === kind;
+    return false;
+  }
   switch (shape.kind) {
     case "primitive":
       if (shape.type === "None") {
         return type === "None" || isOptionType(type);
       }
-      return !isOptionType(type) && familyOf(shape.type).includes(type);
+      return typeof type === "string" && familyOf(shape.type).includes(type);
     case "value":
       if (shape.type === "None") {
         return type === "None" || isOptionType(type);
@@ -3666,7 +4143,22 @@ function describe(shape) {
   }
 }
 function typeName2(type) {
-  return isOptionType(type) ? `Option(${typeName2(type.Option)})` : type;
+  if (isDigestType(type)) {
+    return digestTypeName(type);
+  }
+  if (isFixedPointType(type)) {
+    return fixedPointTypeName(type);
+  }
+  if (isOptionType(type)) {
+    return `Option(${typeName2(type.Option)})`;
+  }
+  if (isListType(type)) {
+    return `List(${typeName2(type.List)})`;
+  }
+  if (isRecordType(type)) {
+    return `Record(${type.Record.map((field) => `${field.name}: ${typeName2(field.type)}`).join(", ")})`;
+  }
+  return type;
 }
 
 // src/shape/transform.ts
@@ -4325,10 +4817,14 @@ function asFrameResults(results) {
 export {
   BlobValue,
   BooleanValue,
+  DECIMAL_DEFAULT_SCALE,
   DateTimeValue,
   DateValue,
   DecimalValue,
+  DigestValue,
   DurationValue,
+  FIXED_POINT_MAX_PRECISION,
+  FIXED_POINT_NARROW_PRECISION,
   Float4Value,
   Float8Value,
   IdentityIdValue,
@@ -4337,6 +4833,7 @@ export {
   Int2Value,
   Int4Value,
   Int8Value,
+  ListValue,
   NONE_PRESENTATION,
   NONE_VALUE,
   NoneValue,
@@ -4347,6 +4844,7 @@ export {
   RQL_OPERATORS,
   RQL_SYSTEM_COLUMNS,
   RQL_TYPES,
+  RecordValue,
   ReifyError,
   Shape,
   ShapeBuilder,
@@ -4368,19 +4866,31 @@ export {
   checkFrames,
   columnsFromWire,
   columnsToRows,
+  decimalType,
   decode,
+  digestType,
+  digestTypeName,
   displayWidth,
   encodeParams,
   encodeValue,
   envelopeToColumns,
   envelopesToFrames,
+  fixedPointKind,
+  fixedPointPrecision,
+  fixedPointScale,
+  fixedPointType,
+  fixedPointTypeName,
   formatValue,
   framesFromWire,
   graphemeWidth,
   inferColumns,
   innerOfOption,
+  isDigestType,
+  isFixedPointType,
+  isListType,
   isOption,
   isOptionType,
+  isRecordType,
   noneDepth,
   noneMarker,
   noneMarkerDepth,